Push before general cleanup to avoid merge errors

node_modules/googleapis/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

node_modules/googleapis/README.md

@@ -0,0 +1,665 @@
+<img src="https://avatars0.githubusercontent.com/u/1342004?v=3&s=96" alt="Google Inc. logo" title="Google" align="right" height="96" width="96"/>
+
+# Google APIs Node.js Client
+
+[![npm version][npmimg]][npm]
+[![Downloads][downloadsimg]][downloads]
+[![Dependency Status][david-image]][david-url]
+[![Known Vulnerabilities][snyk-image]][snyk-url]
+
+[Node.js][node] client library for using Google APIs. Support for authorization and authentication with OAuth 2.0, API Keys and JWT tokens is included.
+
+* [Google APIs](#google-apis)
+* [Getting started](#getting-started)
+  * [Installation](#installation)
+  * [Using the client library](#using-the-client-library)
+  * [Samples](#samples)
+  * [API Reference](#api-reference)
+* [Authentication and authorization](#authentication-and-authorization)
+  * [OAuth2 client](#oauth2-client)
+  * [Using API keys](#using-api-keys)
+  * [Application default credentials](#application-default-credentials)
+  * [Service account credentials](#service-account-credentials)
+  * [Setting global or service-level auth](#setting-global-or-service-level-auth)
+* [Usage](#usage)
+  * [Specifying request body](#specifying-request-body)
+  * [Media uploads](#media-uploads)
+  * [Request Options](#request-options)
+  * [Using a Proxy](#using-a-proxy)
+  * [Supported APIs](#getting-supported-apis)
+  * [TypeScript](#typescript)
+  * [HTTP/2](#http2)
+* [License](#license)
+* [Contributing](#contributing)
+* [Questions/problems?](#questionsproblems)
+
+## Google APIs
+The full list of supported APIs can be found on the [Google APIs Explorer][apiexplorer]. The API endpoints are automatically generated, so if the API is not in the list, it is currently not supported by this API client library.
+
+### Working with Google Cloud Platform APIs?
+If you're working with [Google Cloud Platform][cloudplatform] APIs such as Datastore, Cloud Storage or Pub/Sub, consider using the [`@google-cloud`][googlecloud] client libraries: single purpose idiomatic Node.js clients for Google Cloud Platform services.
+
+### Support and maintenance
+These client libraries are officially supported by Google. However, these libraries are considered complete and are in maintenance mode. This means that we will address critical bugs and security issues but will not add any new features. For Google Cloud Platform APIs, we recommend using [google-cloud-node](https://github.com/GoogleCloudPlatform/google-cloud-node) which is under active development.
+
+This library supports the maintenance LTS, active LTS, and current release of node.js.  See the [node.js release schedule](https://github.com/nodejs/Release) for more information.
+
+## Getting started
+
+### Installation
+This library is distributed on `npm`. In order to add it as a dependency, run the following command:
+
+``` sh
+$ npm install googleapis
+```
+
+If you need to reduce startup times, you can alternatively install a submodule as its own dependency. We make an effort to publish submodules that are __not__ in this [list](https://github.com/googleapis/google-cloud-node#google-cloud-nodejs-client-libraries). In order to add it as a dependency, run the following sample command, replacing with your preferred API:
+
+``` sh
+$ npm install @googleapis/docs
+```
+
+You can run [this search](https://www.npmjs.com/search?q=scope%3Agoogleapis) on npm, to find a list of the submodules available.
+### Using the client library
+
+This is a very simple example. This creates a Blogger client and retrieves the details of a blog given the blog Id:
+
+``` js
+const {google} = require('googleapis');
+
+// Each API may support multiple versions. With this sample, we're getting
+// v3 of the blogger API, and using an API key to authenticate.
+const blogger = google.blogger({
+  version: 'v3',
+  auth: 'YOUR API KEY'
+});
+
+const params = {
+  blogId: '3213900'
+};
+
+// get the blog details
+blogger.blogs.get(params, (err, res) => {
+  if (err) {
+    console.error(err);
+    throw err;
+  }
+  console.log(`The blog url is ${res.data.url}`);
+});
+```
+
+Instead of using callbacks you can also use promises!
+
+``` js
+blogger.blogs.get(params)
+  .then(res => {
+    console.log(`The blog url is ${res.data.url}`);
+  })
+  .catch(error => {
+    console.error(error);
+  });
+```
+
+Or async/await:
+
+``` js
+async function runSample() {
+  const res = await blogger.blogs.get(params);
+  console.log(`The blog url is ${res.data.url}`);
+}
+runSample().catch(console.error);
+```
+
+Alternatively, you can make calls directly to the APIs by installing a submodule:
+
+``` js
+const docs = require('@googleapis/docs')
+
+const auth = new docs.auth.GoogleAuth({
+  keyFilename: 'PATH_TO_SERVICE_ACCOUNT_KEY.json',
+    // Scopes can be specified either as an array or as a single, space-delimited string.
+  scopes: ['https://www.googleapis.com/auth/documents']
+});
+const authClient = await auth.getClient();
+
+const client = await docs.docs({
+    version: 'v1',
+    auth: authClient
+});
+
+const createResponse = await client.documents.create({
+    requestBody: {
+      title: 'Your new document!',
+    },
+});
+
+console.log(createResponse.data);
+```
+
+### Samples
+There are a lot of [samples](https://github.com/googleapis/google-api-nodejs-client/tree/main/samples) 🤗  If you're trying to figure out how to use an API ... look there first! If there's a sample you need missing, feel free to file an [issue][bugs].
+
+### API Reference
+This library has a full set of [API Reference Documentation](https://googleapis.dev/nodejs/googleapis/latest). This documentation is auto-generated, and the location may change.
+
+## Authentication and authorization
+There are multiple ways to authenticate to Google APIs. Some service support all authentication methods, other may only support one or two.
+
+- **OAuth2** - This allows you to make API calls on behalf of a given user.  In this model, the user visits your application, signs in with their Google account, and provides your application with authorization against a set of scopes.  [Learn more](#oauth2-client).
+
+- **API Key** - With an API key, you can access your service from a client or the server.  Typically less secure, this is only available on a small subset of services with limited scopes.  [Learn more](#using-api-keys).
+
+- **Application default credentials** - Provides automatic access to Google APIs using the [Google Cloud SDK](https://cloud.google.com/sdk/) for local development, or the [GCE Metadata Server](https://cloud.google.com/compute/docs/storing-retrieving-metadata) for applications deployed to Google Cloud Platform. [Learn more](#application-default-credentials).
+
+- **Service account credentials** - In this model, your application talks directly to Google APIs using a Service Account. It's useful when you have a backend application that will talk directly to Google APIs from the backend. [Learn more](#service-account-credentials).
+
+To learn more about the authentication client, see the [Google Auth Library](https://github.com/googleapis/google-auth-library-nodejs).
+
+### OAuth2 client
+This module comes with an [OAuth2][oauth] client that allows you to retrieve an access token, refresh it, and retry the request seamlessly. The basics of Google's OAuth2 implementation is explained on [Google Authorization and Authentication documentation][authdocs].
+
+In the following examples, you may need a `CLIENT_ID`, `CLIENT_SECRET` and `REDIRECT_URL`. You can find these pieces of information by going to the [Developer Console][devconsole], clicking your project --> APIs & auth --> credentials.
+- Navigate to the Cloud Console and [Create a new OAuth2 Client Id](https://console.cloud.google.com/apis/credentials/oauthclient)
+- Select `Web Application` for the application type
+- Add an authorized redirect URI with the value `http://localhost:3000/oauth2callback` (or applicable value for your scenario)
+- Click `Create`, and `Ok` on the following screen
+- Click the `Download` icon next to your newly created OAuth2 Client Id
+
+Make sure to store this file in safe place, and *do not check this file into source control!*
+
+For more information about OAuth2 and how it works, [see here][oauth].
+
+A complete sample application that authorizes and authenticates with the OAuth2 client is available at [`samples/oauth2.js`][oauthexample].
+
+#### Generating an authentication URL
+
+To ask for permissions from a user to retrieve an access token, you redirect them to a consent page. To create a consent page URL:
+
+``` js
+const {google} = require('googleapis');
+
+const oauth2Client = new google.auth.OAuth2(
+  YOUR_CLIENT_ID,
+  YOUR_CLIENT_SECRET,
+  YOUR_REDIRECT_URL
+);
+
+// generate a url that asks permissions for Blogger and Google Calendar scopes
+const scopes = [
+  'https://www.googleapis.com/auth/blogger',
+  'https://www.googleapis.com/auth/calendar'
+];
+
+const url = oauth2Client.generateAuthUrl({
+  // 'online' (default) or 'offline' (gets refresh_token)
+  access_type: 'offline',
+
+  // If you only need one scope you can pass it as a string
+  scope: scopes
+});
+```
+
+**IMPORTANT NOTE** - The `refresh_token` is only returned on the first authorization. More details [here](https://github.com/googleapis/google-api-nodejs-client/issues/750#issuecomment-304521450).
+
+#### Retrieve authorization code
+
+Once a user has given permissions on the consent page, Google will redirect the page to the redirect URL you have provided with a code query parameter.
+
+    GET /oauthcallback?code={authorizationCode}
+
+#### Retrieve access token
+
+With the code returned, you can ask for an access token as shown below:
+
+``` js
+// This will provide an object with the access_token and refresh_token.
+// Save these somewhere safe so they can be used at a later time.
+const {tokens} = await oauth2Client.getToken(code)
+oauth2Client.setCredentials(tokens);
+```
+
+With the credentials set on your OAuth2 client - you're ready to go!
+
+#### Handling refresh tokens
+Access tokens expire. This library will automatically use a refresh token to obtain a new access token if it is about to expire. An easy way to make sure you always store the most recent tokens is to use the `tokens` event:
+
+```js
+oauth2Client.on('tokens', (tokens) => {
+  if (tokens.refresh_token) {
+    // store the refresh_token in my database!
+    console.log(tokens.refresh_token);
+  }
+  console.log(tokens.access_token);
+});
+```
+This tokens event only occurs in the first authorization, and you need to have set your `access_type` to `offline` when calling the  `generateAuthUrl` method to receive the refresh token. If you have already given your app the requisiste permissions without setting the appropriate constraints for receiving a refresh token, you will need to re-authorize the application to receive a fresh refresh token. You can revoke your app's access to your account [here](https://myaccount.google.com/permissions).
+
+To set the `refresh_token` at a later time, you can use the `setCredentials` method:
+
+```js
+oauth2Client.setCredentials({
+  refresh_token: `STORED_REFRESH_TOKEN`
+});
+```
+
+Once the client has a refresh token, access tokens will be acquired and refreshed automatically in the next call to the API.
+
+Refresh tokens may stop working after they are granted, either because:
+- The user has revoked your app's access
+- The refresh token has not been used for 6 months
+- The user changed passwords and the refresh token contains Gmail scopes
+- The user account has exceeded a max number of live refresh tokens
+- The application has a status of 'Testing' and the consent screen is configured for an external user type, causing the token to expire in 7 days
+
+As a developer, you should write your code to handle the case where a refresh token is no longer working.
+
+
+### Using API keys
+You may need to send an API key with the request you are going to make. The following uses an API key to make a request to the Blogger API service to retrieve a blog's name, url, and its total amount of posts:
+
+``` js
+const {google} = require('googleapis');
+const blogger = google.blogger_v3({
+  version: 'v3',
+  auth: 'YOUR_API_KEY' // specify your API key here
+});
+
+const params = {
+  blogId: '3213900'
+};
+
+async function main(params) {
+  const res = await blogger.blogs.get({blogId: params.blogId});
+  console.log(`${res.data.name} has ${res.data.posts.totalItems} posts! The blog url is ${res.data.url}`)
+};
+
+main().catch(console.error);
+```
+
+To learn more about API keys, please see the [documentation][usingkeys].
+
+#### Application default credentials
+
+Rather than manually creating an OAuth2 client, JWT client, or Compute client, the auth library can create the correct credential type for you, depending upon the environment your code is running under.
+
+For example, a JWT auth client will be created when your code is running on your local developer machine, and a Compute client will be created when the same code is running on a configured instance of Google Compute Engine. The code below shows how to retrieve a default credential type, depending upon the runtime environment.
+
+To use Application default credentials locally with the [Google Cloud SDK](https://cloud.google.com/sdk/), run:
+
+```sh
+$ gcloud auth application-default login
+```
+
+When running in GCP, service authorize is automatically provided via the GCE Metadata server.
+
+```js
+const {google} = require('googleapis');
+const compute = google.compute('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/compute']
+  });
+  const authClient = await auth.getClient();
+
+  // obtain the current project Id
+  const project = await auth.getProjectId();
+
+  // Fetch the list of GCE zones within a project.
+  const res = await compute.zones.list({ project, auth: authClient });
+  console.log(res.data);
+}
+
+main().catch(console.error);
+```
+
+### Service account credentials
+
+Service accounts allow you to perform server to server, app-level authentication using a robot account.  You will create a service account, download a keyfile, and use that to authenticate to Google APIs.  To create a service account:
+- Go to the [Create Service Account Key page](https://console.cloud.google.com/apis/credentials/serviceaccountkey)
+- Select `New Service Account` in the drop down
+- Click the `Create` button
+
+Save the service account credential file somewhere safe, and *do not check this file into source control*!  To reference the service account credential file, you have a few options.
+
+#### Using the `GOOGLE_APPLICATION_CREDENTIALS` env var
+You can start process with an environment variable named `GOOGLE_APPLICATION_CREDENTIALS`. The value of this env var should be the full path to the service account credential file:
+
+```
+$ GOOGLE_APPLICATION_CREDENTIALS=./your-secret-key.json node server.js
+```
+
+#### Using the `keyFile` property
+Alternatively, you can specify the path to the service account credential file via the `keyFile` property in the `GoogleAuth` constructor:
+
+```js
+const {google} = require('googleapis');
+
+const auth = new google.auth.GoogleAuth({
+  keyFile: '/path/to/your-secret-key.json',
+  scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+});
+```
+
+
+### Setting global or service-level auth
+
+You can set the `auth` as a global or service-level option so you don't need to specify it every request. For example, you can set `auth` as a global option:
+
+``` js
+const {google} = require('googleapis');
+
+const oauth2Client = new google.auth.OAuth2(
+  YOUR_CLIENT_ID,
+  YOUR_CLIENT_SECRET,
+  YOUR_REDIRECT_URL
+);
+
+// set auth as a global default
+google.options({
+  auth: oauth2Client
+});
+```
+
+Instead of setting the option globally, you can also set the authentication client at the service-level:
+
+``` js
+const {google} = require('googleapis');
+const oauth2Client = new google.auth.OAuth2(
+  YOUR_CLIENT_ID,
+  YOUR_CLIENT_SECRET,
+  YOUR_REDIRECT_URL
+);
+
+const drive = google.drive({
+  version: 'v2',
+  auth: oauth2Client
+});
+```
+
+See the [Options section](#request-options) for more information.
+
+## Usage
+
+### Specifying request body
+
+The body of the request is specified in the `requestBody` parameter object of the request. The body is specified as a JavaScript object with key/value pairs. For example, this sample creates a watcher that posts notifications to a Google Cloud Pub/Sub topic when emails are sent to a gmail account:
+
+```js
+const res = await gmail.users.watch({
+  userId: 'me',
+  requestBody: {
+    // Replace with `projects/${PROJECT_ID}/topics/${TOPIC_NAME}`
+    topicName: `projects/el-gato/topics/gmail`
+  }
+});
+console.log(res.data);
+```
+
+### Media uploads
+This client supports multipart media uploads. The resource parameters are specified in the `requestBody` parameter object, and the media itself is specified in the `media.body` parameter with mime-type specified in `media.mimeType`.
+
+This example uploads a plain text file to Google Drive with the title "Test" and contents "Hello World".
+
+``` js
+const drive = google.drive({
+  version: 'v3',
+  auth: oauth2Client
+});
+
+const res = await drive.files.create({
+  requestBody: {
+    name: 'Test',
+    mimeType: 'text/plain'
+  },
+  media: {
+    mimeType: 'text/plain',
+    body: 'Hello World'
+  }
+});
+```
+
+You can also upload media by specifying `media.body` as a [Readable stream][stream]. This can allow you to upload very large files that cannot fit into memory.
+
+```js
+const fs = require('fs');
+
+const drive = google.drive({
+  version: 'v3',
+  auth: oauth2Client
+});
+
+async function main() {
+  const res = await drive.files.create({
+    requestBody: {
+      name: 'testimage.png',
+      mimeType: 'image/png'
+    },
+    media: {
+      mimeType: 'image/png',
+      body: fs.createReadStream('awesome.png')
+    }
+  });
+  console.log(res.data);
+}
+
+main().catch(console.error);
+```
+
+For more examples of creation and modification requests with media attachments, take a look at the `samples/drive/upload.js` sample.
+
+### Request Options
+For more fine-tuned control over how your API calls are made, we provide you with the ability to specify additional options that can be applied directly to the ['gaxios'][gaxios] object used in this library to make network calls to the API.
+
+You may specify additional options either in the global `google` object or on a service client basis. The options you specify are attached to the `gaxios` object so whatever `gaxios` supports, this library supports. You may also specify global or per-service request parameters that will be attached to all API calls you make.
+
+A full list of supported options can be [found here](https://github.com/googleapis/gaxios/#request-options).
+
+#### Global options
+You can choose default options that will be sent with each request. These options will be used for every service instantiated by the google client. In this example, the `timeout` property of `GaxiosOptions` will be set for every request:
+
+```js
+const {google} = require('googleapis');
+google.options({
+  // All requests made with this object will use these settings unless overridden.
+  timeout: 1000,
+  auth: auth
+});
+```
+
+You can also modify the parameters sent with each request:
+
+```js
+const {google} = require('googleapis');
+google.options({
+  // All requests from all services will contain the above query parameter
+  // unless overridden either in a service client or in individual API calls.
+  params: {
+    quotaUser: 'user123@example.com'
+  }
+});
+```
+
+#### Service-client options
+
+You can also specify options when creating a service client.
+
+```js
+const blogger = google.blogger({
+  version: 'v3',
+  // All requests made with this object will use the specified auth.
+  auth: 'API KEY';
+});
+```
+
+By doing this, every API call made with this service client will use `'API KEY'` to authenticate.
+
+**Note:** Created clients are **immutable** so you must create a new one if you want to specify different options.
+
+Similar to the examples above, you can also modify the parameters used for every call of a given service:
+
+```js
+const blogger = google.blogger({
+  version: 'v3',
+  // All requests made with this service client will contain the
+  // blogId query parameter unless overridden in individual API calls.
+  params: {
+    blogId: '3213900'
+  }
+});
+
+// Calls with this drive client will NOT contain the blogId query parameter.
+const drive = google.drive('v3');
+...
+
+```
+
+#### Request-level options
+You can specify an `auth` object to be used per request. Each request also inherits the options specified at the service level and global level.
+
+For example:
+
+```js
+const {google} = require('googleapis');
+const bigquery = google.bigquery('v2');
+
+async function main() {
+
+  // This method looks for the GCLOUD_PROJECT and GOOGLE_APPLICATION_CREDENTIALS
+  // environment variables.
+  const auth = new google.auth.GoogleAuth({
+    scopes: ['https://www.googleapis.com/auth/cloud-platform']
+  });
+  const authClient = await auth.getClient();
+
+  const projectId = await auth.getProjectId();
+
+  const request = {
+    projectId,
+    datasetId: '<YOUR_DATASET_ID>',
+
+    // This is a "request-level" option
+    auth: authClient
+  };
+
+  const res = await bigquery.datasets.delete(request);
+  console.log(res.data);
+
+}
+
+main().catch(console.error);
+```
+
+You can also override *gaxios* options per request, such as `url`, `method`, and `responseType`.
+
+For example:
+
+```js
+const res = await drive.files.export({
+  fileId: 'asxKJod9s79', // A Google Doc
+  mimeType: 'application/pdf'
+}, {
+  // Make sure we get the binary data
+  responseType: 'stream'
+});
+```
+
+### Using a Proxy
+You can use the following environment variables to proxy HTTP and HTTPS requests:
+
+- `HTTP_PROXY` / `http_proxy`
+- `HTTPS_PROXY` / `https_proxy`
+
+When HTTP_PROXY / http_proxy are set, they will be used to proxy non-SSL requests that do not have an explicit proxy configuration option present. Similarly, HTTPS_PROXY / https_proxy will be respected for SSL requests that do not have an explicit proxy configuration option. It is valid to define a proxy in one of the environment variables, but then override it for a specific request, using the proxy configuration option.
+
+### Getting Supported APIs
+You can programmatically obtain the list of supported APIs, and all available versions:
+
+```js
+const {google} = require('googleapis');
+const apis = google.getSupportedAPIs();
+```
+
+This will return an object with the API name as object property names, and an array of version strings as the object values;
+
+### TypeScript
+This library is written in TypeScript, and provides types out of the box. All classes and interfaces generated for each API are exported under the `${apiName}_${version}` namespace. For example, the Drive v3 API types are all available from the `drive_v3` namespace:
+
+```ts
+import {
+  google,   // The top level object used to access services
+  drive_v3, // For every service client, there is an exported namespace
+  Auth,     // Namespace for auth related types
+  Common,   // General types used throughout the library
+} from 'googleapis';
+
+// Note: using explicit types like `Auth.GoogleAuth` are only here for
+// demonstration purposes.  Generally with TypeScript, these types would
+// be inferred.
+const auth: Auth.GoogleAuth = new google.auth.GoogleAuth();
+const drive: drive_v3.Drive = google.drive({
+  version: 'v3',
+  auth,
+});
+
+// There are generated types for every set of request parameters
+const listParams: drive_v3.Params$Resource$Files$List = {};
+const res = await drive.files.list(listParams);
+
+// There are generated types for the response fields as well
+const listResults: drive_v3.Schema$FileList = res.data;
+```
+
+### HTTP/2
+This library has support for [HTTP/2](https://developers.google.com/web/fundamentals/performance/http2). To enable it, use the `http2` option anywhere request parameters are accepted:
+
+```js
+const {google} = require('googleapis');
+google.options({
+  http2: true,
+});
+```
+
+HTTP/2 is often more performant, as it allows multiplexing of multiple concurrent requests over a single socket. In a traditional HTTP/2 API, the client is directly responsible for opening and closing the sessions made to make requests.  To maintain compatibility with the existing API, this module will automatically re-use existing sessions, which are collected after idling for 500ms.  Much of the performance gains will be visible in batch style workloads, and tight loops.
+
+## Release Notes & Breaking Changes
+You can find a detailed list of breaking changes and new features in our [Release Notes][releasenotes]. If you've used this library before `25.x`, see our [Release Notes][releasenotes] to learn about migrating your code from `24.x.x` to `25.x.x`. It's pretty easy :)
+
+## License
+This library is licensed under Apache 2.0. Full license text is available in [LICENSE][license].
+
+## Contributing
+We love contributions! Before submitting a Pull Request, it's always good to start with a new issue first. To learn more, see [CONTRIBUTING][contributing].
+
+## Questions/problems?
+* Ask your development related questions on [Stackoverflow][stackoverflow].
+* If you've found an bug/issue, please [file it on GitHub][bugs].
+
+
+[snyk-image]: https://snyk.io/test/github/googleapis/google-api-nodejs-client/badge.svg
+[snyk-url]: https://snyk.io/test/github/googleapis/google-api-nodejs-client
+[david-image]: https://david-dm.org/googleapis/google-api-nodejs-client.svg
+[david-url]: https://david-dm.org/googleapis/google-api-nodejs-client
+[npmimg]: https://img.shields.io/npm/v/googleapis.svg
+[npm]: https://www.npmjs.org/package/googleapis
+[bugs]: https://github.com/googleapis/google-api-nodejs-client/issues
+[node]: http://nodejs.org/
+[stackoverflow]: http://stackoverflow.com/questions/tagged/google-api-nodejs-client
+[apiexplorer]: https://developers.google.com/apis-explorer
+[usingkeys]: https://support.google.com/cloud/answer/6158862?hl=en
+[contributing]: https://github.com/googleapis/google-api-nodejs-client/blob/main/CONTRIBUTING.md
+[license]: https://github.com/googleapis/google-api-nodejs-client/tree/main/LICENSE
+[authdocs]: https://developers.google.com/identity/protocols/OpenIDConnect
+[gaxios]: https://github.com/JustinBeckwith/gaxios
+[stream]: http://nodejs.org/api/stream.html#stream_class_stream_readable
+[releasenotes]: https://github.com/googleapis/google-api-nodejs-client/releases
+[devconsole]: https://console.cloud.google.com/apis/credentials
+[oauth]: https://developers.google.com/identity/protocols/OAuth2
+[oauthexample]: https://github.com/googleapis/google-api-nodejs-client/tree/main/samples/oauth2.js
+[options]: https://github.com/googleapis/google-api-nodejs-client/tree/main#options
+[googlecloud]: https://cloud.google.com/nodejs/docs/reference/libraries
+[googlecloudapis]: https://cloud.google.com/nodejs/docs/reference/apis
+[cloudplatform]: https://cloud.google.com/docs/
+[downloadsimg]: https://img.shields.io/npm/dm/googleapis.svg
+[downloads]: https://www.npmjs.com/package/googleapis

node_modules/googleapis/build/src/apis/abusiveexperiencereport/index.d.ts

@@ -0,0 +1,12 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { abusiveexperiencereport_v1 } from './v1';
+export declare const VERSIONS: {
+    v1: typeof abusiveexperiencereport_v1.Abusiveexperiencereport;
+};
+export declare function abusiveexperiencereport(version: 'v1'): abusiveexperiencereport_v1.Abusiveexperiencereport;
+export declare function abusiveexperiencereport(options: abusiveexperiencereport_v1.Options): abusiveexperiencereport_v1.Abusiveexperiencereport;
+declare const auth: AuthPlus;
+export { auth };
+export { abusiveexperiencereport_v1 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/abusiveexperiencereport/v1.d.ts

@@ -0,0 +1,249 @@
+/// <reference types="node" />
+import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosPromise, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
+import { Readable } from 'stream';
+export declare namespace abusiveexperiencereport_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;
+    }
+    /**
+     * Abusive Experience Report API
+     *
+     * Views Abusive Experience Report data, and gets a list of sites that have a significant number of abusive experiences.
+     *
+     * @example
+     * ```js
+     * const {google} = require('googleapis');
+     * const abusiveexperiencereport = google.abusiveexperiencereport('v1');
+     * ```
+     */
+    export class Abusiveexperiencereport {
+        context: APIRequestContext;
+        sites: Resource$Sites;
+        violatingSites: Resource$Violatingsites;
+        constructor(options: GlobalOptions, google?: GoogleConfigurable);
+    }
+    /**
+     * Response message for GetSiteSummary.
+     */
+    export interface Schema$SiteSummaryResponse {
+        /**
+         * The site's Abusive Experience Report status.
+         */
+        abusiveStatus?: string | null;
+        /**
+         * The time at which [enforcement](https://support.google.com/webtools/answer/7538608) against the site began or will begin. Not set when the filter_status is OFF.
+         */
+        enforcementTime?: string | null;
+        /**
+         * The site's [enforcement status](https://support.google.com/webtools/answer/7538608).
+         */
+        filterStatus?: string | null;
+        /**
+         * The time at which the site's status last changed.
+         */
+        lastChangeTime?: string | null;
+        /**
+         * A link to the full Abusive Experience Report for the site. Not set in ViolatingSitesResponse. Note that you must complete the [Search Console verification process](https://support.google.com/webmasters/answer/9008080) for the site before you can access the full report.
+         */
+        reportUrl?: string | null;
+        /**
+         * The name of the reviewed site, e.g. `google.com`.
+         */
+        reviewedSite?: string | null;
+        /**
+         * Whether the site is currently under review.
+         */
+        underReview?: boolean | null;
+    }
+    /**
+     * Response message for ListViolatingSites.
+     */
+    export interface Schema$ViolatingSitesResponse {
+        /**
+         * The list of violating sites.
+         */
+        violatingSites?: Schema$SiteSummaryResponse[];
+    }
+    export class Resource$Sites {
+        context: APIRequestContext;
+        constructor(context: APIRequestContext);
+        /**
+         * Gets a site's Abusive Experience Report summary.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/abusiveexperiencereport.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const abusiveexperiencereport = google.abusiveexperiencereport('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: [],
+         *   });
+         *
+         *   // 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 abusiveexperiencereport.sites.get({
+         *     // Required. The name of the site whose summary to get, e.g. `sites/http%3A%2F%2Fwww.google.com%2F`. Format: `sites/{site\}`
+         *     name: 'sites/my-site',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "abusiveStatus": "my_abusiveStatus",
+         *   //   "enforcementTime": "my_enforcementTime",
+         *   //   "filterStatus": "my_filterStatus",
+         *   //   "lastChangeTime": "my_lastChangeTime",
+         *   //   "reportUrl": "my_reportUrl",
+         *   //   "reviewedSite": "my_reviewedSite",
+         *   //   "underReview": false
+         *   // }
+         * }
+         *
+         * 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$Sites$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        get(params?: Params$Resource$Sites$Get, options?: MethodOptions): GaxiosPromise<Schema$SiteSummaryResponse>;
+        get(params: Params$Resource$Sites$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        get(params: Params$Resource$Sites$Get, options: MethodOptions | BodyResponseCallback<Schema$SiteSummaryResponse>, callback: BodyResponseCallback<Schema$SiteSummaryResponse>): void;
+        get(params: Params$Resource$Sites$Get, callback: BodyResponseCallback<Schema$SiteSummaryResponse>): void;
+        get(callback: BodyResponseCallback<Schema$SiteSummaryResponse>): void;
+    }
+    export interface Params$Resource$Sites$Get extends StandardParameters {
+        /**
+         * Required. The name of the site whose summary to get, e.g. `sites/http%3A%2F%2Fwww.google.com%2F`. Format: `sites/{site\}`
+         */
+        name?: string;
+    }
+    export class Resource$Violatingsites {
+        context: APIRequestContext;
+        constructor(context: APIRequestContext);
+        /**
+         * Lists sites that are failing in the Abusive Experience Report.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/abusiveexperiencereport.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const abusiveexperiencereport = google.abusiveexperiencereport('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: [],
+         *   });
+         *
+         *   // 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 abusiveexperiencereport.violatingSites.list({});
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "violatingSites": []
+         *   // }
+         * }
+         *
+         * 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$Violatingsites$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        list(params?: Params$Resource$Violatingsites$List, options?: MethodOptions): GaxiosPromise<Schema$ViolatingSitesResponse>;
+        list(params: Params$Resource$Violatingsites$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        list(params: Params$Resource$Violatingsites$List, options: MethodOptions | BodyResponseCallback<Schema$ViolatingSitesResponse>, callback: BodyResponseCallback<Schema$ViolatingSitesResponse>): void;
+        list(params: Params$Resource$Violatingsites$List, callback: BodyResponseCallback<Schema$ViolatingSitesResponse>): void;
+        list(callback: BodyResponseCallback<Schema$ViolatingSitesResponse>): void;
+    }
+    export interface Params$Resource$Violatingsites$List extends StandardParameters {
+    }
+    export {};
+}

node_modules/googleapis/build/src/apis/acceleratedmobilepageurl/index.d.ts

@@ -0,0 +1,12 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { acceleratedmobilepageurl_v1 } from './v1';
+export declare const VERSIONS: {
+    v1: typeof acceleratedmobilepageurl_v1.Acceleratedmobilepageurl;
+};
+export declare function acceleratedmobilepageurl(version: 'v1'): acceleratedmobilepageurl_v1.Acceleratedmobilepageurl;
+export declare function acceleratedmobilepageurl(options: acceleratedmobilepageurl_v1.Options): acceleratedmobilepageurl_v1.Acceleratedmobilepageurl;
+declare const auth: AuthPlus;
+export { auth };
+export { acceleratedmobilepageurl_v1 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/acceleratedmobilepageurl/v1.d.ts

@@ -0,0 +1,208 @@
+/// <reference types="node" />
+import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosPromise, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
+import { Readable } from 'stream';
+export declare namespace acceleratedmobilepageurl_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;
+    }
+    /**
+     * Accelerated Mobile Pages (AMP) URL API
+     *
+     * Retrieves the list of AMP URLs (and equivalent AMP Cache URLs) for a given list of public URL(s).
+     *
+     * @example
+     * ```js
+     * const {google} = require('googleapis');
+     * const acceleratedmobilepageurl = google.acceleratedmobilepageurl('v1');
+     * ```
+     */
+    export class Acceleratedmobilepageurl {
+        context: APIRequestContext;
+        ampUrls: Resource$Ampurls;
+        constructor(options: GlobalOptions, google?: GoogleConfigurable);
+    }
+    /**
+     * AMP URL response for a requested URL.
+     */
+    export interface Schema$AmpUrl {
+        /**
+         * The AMP URL pointing to the publisher's web server.
+         */
+        ampUrl?: string | null;
+        /**
+         * The [AMP Cache URL](/amp/cache/overview#amp-cache-url-format) pointing to the cached document in the Google AMP Cache.
+         */
+        cdnAmpUrl?: string | null;
+        /**
+         * The original non-AMP URL.
+         */
+        originalUrl?: string | null;
+    }
+    /**
+     * AMP URL Error resource for a requested URL that couldn't be found.
+     */
+    export interface Schema$AmpUrlError {
+        /**
+         * The error code of an API call.
+         */
+        errorCode?: string | null;
+        /**
+         * An optional descriptive error message.
+         */
+        errorMessage?: string | null;
+        /**
+         * The original non-AMP URL.
+         */
+        originalUrl?: string | null;
+    }
+    /**
+     * AMP URL request for a batch of URLs.
+     */
+    export interface Schema$BatchGetAmpUrlsRequest {
+        /**
+         * The lookup_strategy being requested.
+         */
+        lookupStrategy?: string | null;
+        /**
+         * List of URLs to look up for the paired AMP URLs. The URLs are case-sensitive. Up to 50 URLs per lookup (see [Usage Limits](/amp/cache/reference/limits)).
+         */
+        urls?: string[] | null;
+    }
+    /**
+     * Batch AMP URL response.
+     */
+    export interface Schema$BatchGetAmpUrlsResponse {
+        /**
+         * For each URL in BatchAmpUrlsRequest, the URL response. The response might not be in the same order as URLs in the batch request. If BatchAmpUrlsRequest contains duplicate URLs, AmpUrl is generated only once.
+         */
+        ampUrls?: Schema$AmpUrl[];
+        /**
+         * The errors for requested URLs that have no AMP URL.
+         */
+        urlErrors?: Schema$AmpUrlError[];
+    }
+    export class Resource$Ampurls {
+        context: APIRequestContext;
+        constructor(context: APIRequestContext);
+        /**
+         * Returns AMP URL(s) and equivalent [AMP Cache URL(s)](/amp/cache/overview#amp-cache-url-format).
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/acceleratedmobilepageurl.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const acceleratedmobilepageurl = google.acceleratedmobilepageurl('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: [],
+         *   });
+         *
+         *   // 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 acceleratedmobilepageurl.ampUrls.batchGet({
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "lookupStrategy": "my_lookupStrategy",
+         *       //   "urls": []
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "ampUrls": [],
+         *   //   "urlErrors": []
+         *   // }
+         * }
+         *
+         * 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.
+         */
+        batchGet(params: Params$Resource$Ampurls$Batchget, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        batchGet(params?: Params$Resource$Ampurls$Batchget, options?: MethodOptions): GaxiosPromise<Schema$BatchGetAmpUrlsResponse>;
+        batchGet(params: Params$Resource$Ampurls$Batchget, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        batchGet(params: Params$Resource$Ampurls$Batchget, options: MethodOptions | BodyResponseCallback<Schema$BatchGetAmpUrlsResponse>, callback: BodyResponseCallback<Schema$BatchGetAmpUrlsResponse>): void;
+        batchGet(params: Params$Resource$Ampurls$Batchget, callback: BodyResponseCallback<Schema$BatchGetAmpUrlsResponse>): void;
+        batchGet(callback: BodyResponseCallback<Schema$BatchGetAmpUrlsResponse>): void;
+    }
+    export interface Params$Resource$Ampurls$Batchget extends StandardParameters {
+        /**
+         * Request body metadata
+         */
+        requestBody?: Schema$BatchGetAmpUrlsRequest;
+    }
+    export {};
+}

node_modules/googleapis/build/src/apis/accessapproval/index.d.ts

@@ -0,0 +1,17 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { accessapproval_v1 } from './v1';
+import { accessapproval_v1beta1 } from './v1beta1';
+export declare const VERSIONS: {
+    v1: typeof accessapproval_v1.Accessapproval;
+    v1beta1: typeof accessapproval_v1beta1.Accessapproval;
+};
+export declare function accessapproval(version: 'v1'): accessapproval_v1.Accessapproval;
+export declare function accessapproval(options: accessapproval_v1.Options): accessapproval_v1.Accessapproval;
+export declare function accessapproval(version: 'v1beta1'): accessapproval_v1beta1.Accessapproval;
+export declare function accessapproval(options: accessapproval_v1beta1.Options): accessapproval_v1beta1.Accessapproval;
+declare const auth: AuthPlus;
+export { auth };
+export { accessapproval_v1 };
+export { accessapproval_v1beta1 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/accesscontextmanager/index.d.ts

@@ -0,0 +1,17 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { accesscontextmanager_v1 } from './v1';
+import { accesscontextmanager_v1beta } from './v1beta';
+export declare const VERSIONS: {
+    v1: typeof accesscontextmanager_v1.Accesscontextmanager;
+    v1beta: typeof accesscontextmanager_v1beta.Accesscontextmanager;
+};
+export declare function accesscontextmanager(version: 'v1'): accesscontextmanager_v1.Accesscontextmanager;
+export declare function accesscontextmanager(options: accesscontextmanager_v1.Options): accesscontextmanager_v1.Accesscontextmanager;
+export declare function accesscontextmanager(version: 'v1beta'): accesscontextmanager_v1beta.Accesscontextmanager;
+export declare function accesscontextmanager(options: accesscontextmanager_v1beta.Options): accesscontextmanager_v1beta.Accesscontextmanager;
+declare const auth: AuthPlus;
+export { auth };
+export { accesscontextmanager_v1 };
+export { accesscontextmanager_v1beta };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/adexchangebuyer/index.d.ts

@@ -0,0 +1,22 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { adexchangebuyer_v1_2 } from './v1.2';
+import { adexchangebuyer_v1_3 } from './v1.3';
+import { adexchangebuyer_v1_4 } from './v1.4';
+export declare const VERSIONS: {
+    'v1.2': typeof adexchangebuyer_v1_2.Adexchangebuyer;
+    'v1.3': typeof adexchangebuyer_v1_3.Adexchangebuyer;
+    'v1.4': typeof adexchangebuyer_v1_4.Adexchangebuyer;
+};
+export declare function adexchangebuyer(version: 'v1.2'): adexchangebuyer_v1_2.Adexchangebuyer;
+export declare function adexchangebuyer(options: adexchangebuyer_v1_2.Options): adexchangebuyer_v1_2.Adexchangebuyer;
+export declare function adexchangebuyer(version: 'v1.3'): adexchangebuyer_v1_3.Adexchangebuyer;
+export declare function adexchangebuyer(options: adexchangebuyer_v1_3.Options): adexchangebuyer_v1_3.Adexchangebuyer;
+export declare function adexchangebuyer(version: 'v1.4'): adexchangebuyer_v1_4.Adexchangebuyer;
+export declare function adexchangebuyer(options: adexchangebuyer_v1_4.Options): adexchangebuyer_v1_4.Adexchangebuyer;
+declare const auth: AuthPlus;
+export { auth };
+export { adexchangebuyer_v1_2 };
+export { adexchangebuyer_v1_3 };
+export { adexchangebuyer_v1_4 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/adexchangebuyer/v1.2.d.ts

@@ -0,0 +1,826 @@
+/// <reference types="node" />
+import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosPromise, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
+import { Readable } from 'stream';
+export declare namespace adexchangebuyer_v1_2 {
+    export interface Options extends GlobalOptions {
+        version: 'v1.2';
+    }
+    interface StandardParameters {
+        /**
+         * Auth client or API Key for the request
+         */
+        auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient | BaseExternalAccountClient | GoogleAuth;
+        /**
+         * Data format for the response.
+         */
+        alt?: 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;
+        /**
+         * An opaque string that represents a user for quota purposes. Must not exceed 40 characters.
+         */
+        quotaUser?: string;
+        /**
+         * Deprecated. Please use quotaUser instead.
+         */
+        userIp?: string;
+    }
+    /**
+     * Ad Exchange Buyer API
+     *
+     * Accesses your bidding-account information, submits creatives for validation, finds available direct deals, and retrieves performance reports.
+     *
+     * @example
+     * ```js
+     * const {google} = require('googleapis');
+     * const adexchangebuyer = google.adexchangebuyer('v1.2');
+     * ```
+     */
+    export class Adexchangebuyer {
+        context: APIRequestContext;
+        accounts: Resource$Accounts;
+        creatives: Resource$Creatives;
+        constructor(options: GlobalOptions, google?: GoogleConfigurable);
+    }
+    /**
+     * Configuration data for an Ad Exchange buyer account.
+     */
+    export interface Schema$Account {
+        /**
+         * Your bidder locations that have distinct URLs.
+         */
+        bidderLocation?: Array<{
+            maximumQps?: number;
+            region?: string;
+            url?: string;
+        }> | null;
+        /**
+         * The nid parameter value used in cookie match requests. Please contact your technical account manager if you need to change this.
+         */
+        cookieMatchingNid?: string | null;
+        /**
+         * The base URL used in cookie match requests.
+         */
+        cookieMatchingUrl?: string | null;
+        /**
+         * Account id.
+         */
+        id?: number | null;
+        /**
+         * Resource type.
+         */
+        kind?: string | null;
+        /**
+         * The maximum number of active creatives that an account can have, where a creative is active if it was inserted or bid with in the last 30 days. Please contact your technical account manager if you need to change this.
+         */
+        maximumActiveCreatives?: number | null;
+        /**
+         * The sum of all bidderLocation.maximumQps values cannot exceed this. Please contact your technical account manager if you need to change this.
+         */
+        maximumTotalQps?: number | null;
+        /**
+         * The number of creatives that this account inserted or bid with in the last 30 days.
+         */
+        numberActiveCreatives?: number | null;
+    }
+    /**
+     * An account feed lists Ad Exchange buyer accounts that the user has access to. Each entry in the feed corresponds to a single buyer account.
+     */
+    export interface Schema$AccountsList {
+        /**
+         * A list of accounts.
+         */
+        items?: Schema$Account[];
+        /**
+         * Resource type.
+         */
+        kind?: string | null;
+    }
+    /**
+     * A creative and its classification data.
+     */
+    export interface Schema$Creative {
+        /**
+         * Account id.
+         */
+        accountId?: number | null;
+        /**
+         * Detected advertiser id, if any. Read-only. This field should not be set in requests.
+         */
+        advertiserId?: string[] | null;
+        /**
+         * The name of the company being advertised in the creative.
+         */
+        advertiserName?: string | null;
+        /**
+         * The agency id for this creative.
+         */
+        agencyId?: string | null;
+        /**
+         * The last upload timestamp of this creative if it was uploaded via API. Read-only. The value of this field is generated, and will be ignored for uploads. (formatted RFC 3339 timestamp).
+         */
+        apiUploadTimestamp?: string | null;
+        /**
+         * All attributes for the ads that may be shown from this snippet.
+         */
+        attribute?: number[] | null;
+        /**
+         * A buyer-specific id identifying the creative in this ad.
+         */
+        buyerCreativeId?: string | null;
+        /**
+         * The set of destination urls for the snippet.
+         */
+        clickThroughUrl?: string[] | null;
+        /**
+         * Shows any corrections that were applied to this creative. Read-only. This field should not be set in requests.
+         */
+        corrections?: Array<{
+            details?: string[];
+            reason?: string;
+        }> | null;
+        /**
+         * The reasons for disapproval, if any. Note that not all disapproval reasons may be categorized, so it is possible for the creative to have a status of DISAPPROVED with an empty list for disapproval_reasons. In this case, please reach out to your TAM to help debug the issue. Read-only. This field should not be set in requests.
+         */
+        disapprovalReasons?: Array<{
+            details?: string[];
+            reason?: string;
+        }> | null;
+        /**
+         * The filtering reasons for the creative. Read-only. This field should not be set in requests.
+         */
+        filteringReasons?: {
+            date?: string;
+            reasons?: Array<{
+                filteringCount?: string;
+                filteringStatus?: number;
+            }>;
+        } | null;
+        /**
+         * Ad height.
+         */
+        height?: number | null;
+        /**
+         * The HTML snippet that displays the ad when inserted in the web page. If set, videoURL should not be set.
+         */
+        HTMLSnippet?: string | null;
+        /**
+         * The set of urls to be called to record an impression.
+         */
+        impressionTrackingUrl?: string[] | null;
+        /**
+         * Resource type.
+         */
+        kind?: string | null;
+        /**
+         * Detected product categories, if any. Read-only. This field should not be set in requests.
+         */
+        productCategories?: number[] | null;
+        /**
+         * All restricted categories for the ads that may be shown from this snippet.
+         */
+        restrictedCategories?: number[] | null;
+        /**
+         * Detected sensitive categories, if any. Read-only. This field should not be set in requests.
+         */
+        sensitiveCategories?: number[] | null;
+        /**
+         * Creative serving status. Read-only. This field should not be set in requests.
+         */
+        status?: string | null;
+        /**
+         * All vendor types for the ads that may be shown from this snippet.
+         */
+        vendorType?: number[] | null;
+        /**
+         * The version for this creative. Read-only. This field should not be set in requests.
+         */
+        version?: number | null;
+        /**
+         * The url to fetch a video ad. If set, HTMLSnippet should not be set.
+         */
+        videoURL?: string | null;
+        /**
+         * Ad width.
+         */
+        width?: number | null;
+    }
+    /**
+     * The creatives feed lists the active creatives for the Ad Exchange buyer accounts that the user has access to. Each entry in the feed corresponds to a single creative.
+     */
+    export interface Schema$CreativesList {
+        /**
+         * A list of creatives.
+         */
+        items?: Schema$Creative[];
+        /**
+         * Resource type.
+         */
+        kind?: string | null;
+        /**
+         * Continuation token used to page through creatives. To retrieve the next page of results, set the next request's "pageToken" value to this.
+         */
+        nextPageToken?: string | null;
+    }
+    export class Resource$Accounts {
+        context: APIRequestContext;
+        constructor(context: APIRequestContext);
+        /**
+         * Gets one account by ID.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/adexchangebuyer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const adexchangebuyer = google.adexchangebuyer('v1.2');
+         *
+         * 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/adexchange.buyer'],
+         *   });
+         *
+         *   // 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 adexchangebuyer.accounts.get({
+         *     // The account id
+         *     id: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "bidderLocation": [],
+         *   //   "cookieMatchingNid": "my_cookieMatchingNid",
+         *   //   "cookieMatchingUrl": "my_cookieMatchingUrl",
+         *   //   "id": 0,
+         *   //   "kind": "my_kind",
+         *   //   "maximumActiveCreatives": 0,
+         *   //   "maximumTotalQps": 0,
+         *   //   "numberActiveCreatives": 0
+         *   // }
+         * }
+         *
+         * 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$Accounts$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        get(params?: Params$Resource$Accounts$Get, options?: MethodOptions): GaxiosPromise<Schema$Account>;
+        get(params: Params$Resource$Accounts$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        get(params: Params$Resource$Accounts$Get, options: MethodOptions | BodyResponseCallback<Schema$Account>, callback: BodyResponseCallback<Schema$Account>): void;
+        get(params: Params$Resource$Accounts$Get, callback: BodyResponseCallback<Schema$Account>): void;
+        get(callback: BodyResponseCallback<Schema$Account>): void;
+        /**
+         * Retrieves the authenticated user's list of accounts.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/adexchangebuyer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const adexchangebuyer = google.adexchangebuyer('v1.2');
+         *
+         * 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/adexchange.buyer'],
+         *   });
+         *
+         *   // 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 adexchangebuyer.accounts.list({});
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "items": [],
+         *   //   "kind": "my_kind"
+         *   // }
+         * }
+         *
+         * 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$Accounts$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        list(params?: Params$Resource$Accounts$List, options?: MethodOptions): GaxiosPromise<Schema$AccountsList>;
+        list(params: Params$Resource$Accounts$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        list(params: Params$Resource$Accounts$List, options: MethodOptions | BodyResponseCallback<Schema$AccountsList>, callback: BodyResponseCallback<Schema$AccountsList>): void;
+        list(params: Params$Resource$Accounts$List, callback: BodyResponseCallback<Schema$AccountsList>): void;
+        list(callback: BodyResponseCallback<Schema$AccountsList>): void;
+        /**
+         * Updates an existing account. This method supports patch semantics.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/adexchangebuyer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const adexchangebuyer = google.adexchangebuyer('v1.2');
+         *
+         * 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/adexchange.buyer'],
+         *   });
+         *
+         *   // 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 adexchangebuyer.accounts.patch({
+         *     // The account id
+         *     id: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "bidderLocation": [],
+         *       //   "cookieMatchingNid": "my_cookieMatchingNid",
+         *       //   "cookieMatchingUrl": "my_cookieMatchingUrl",
+         *       //   "id": 0,
+         *       //   "kind": "my_kind",
+         *       //   "maximumActiveCreatives": 0,
+         *       //   "maximumTotalQps": 0,
+         *       //   "numberActiveCreatives": 0
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "bidderLocation": [],
+         *   //   "cookieMatchingNid": "my_cookieMatchingNid",
+         *   //   "cookieMatchingUrl": "my_cookieMatchingUrl",
+         *   //   "id": 0,
+         *   //   "kind": "my_kind",
+         *   //   "maximumActiveCreatives": 0,
+         *   //   "maximumTotalQps": 0,
+         *   //   "numberActiveCreatives": 0
+         *   // }
+         * }
+         *
+         * 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$Accounts$Patch, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        patch(params?: Params$Resource$Accounts$Patch, options?: MethodOptions): GaxiosPromise<Schema$Account>;
+        patch(params: Params$Resource$Accounts$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        patch(params: Params$Resource$Accounts$Patch, options: MethodOptions | BodyResponseCallback<Schema$Account>, callback: BodyResponseCallback<Schema$Account>): void;
+        patch(params: Params$Resource$Accounts$Patch, callback: BodyResponseCallback<Schema$Account>): void;
+        patch(callback: BodyResponseCallback<Schema$Account>): void;
+        /**
+         * Updates an existing account.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/adexchangebuyer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const adexchangebuyer = google.adexchangebuyer('v1.2');
+         *
+         * 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/adexchange.buyer'],
+         *   });
+         *
+         *   // 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 adexchangebuyer.accounts.update({
+         *     // The account id
+         *     id: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "bidderLocation": [],
+         *       //   "cookieMatchingNid": "my_cookieMatchingNid",
+         *       //   "cookieMatchingUrl": "my_cookieMatchingUrl",
+         *       //   "id": 0,
+         *       //   "kind": "my_kind",
+         *       //   "maximumActiveCreatives": 0,
+         *       //   "maximumTotalQps": 0,
+         *       //   "numberActiveCreatives": 0
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "bidderLocation": [],
+         *   //   "cookieMatchingNid": "my_cookieMatchingNid",
+         *   //   "cookieMatchingUrl": "my_cookieMatchingUrl",
+         *   //   "id": 0,
+         *   //   "kind": "my_kind",
+         *   //   "maximumActiveCreatives": 0,
+         *   //   "maximumTotalQps": 0,
+         *   //   "numberActiveCreatives": 0
+         *   // }
+         * }
+         *
+         * 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.
+         */
+        update(params: Params$Resource$Accounts$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        update(params?: Params$Resource$Accounts$Update, options?: MethodOptions): GaxiosPromise<Schema$Account>;
+        update(params: Params$Resource$Accounts$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        update(params: Params$Resource$Accounts$Update, options: MethodOptions | BodyResponseCallback<Schema$Account>, callback: BodyResponseCallback<Schema$Account>): void;
+        update(params: Params$Resource$Accounts$Update, callback: BodyResponseCallback<Schema$Account>): void;
+        update(callback: BodyResponseCallback<Schema$Account>): void;
+    }
+    export interface Params$Resource$Accounts$Get extends StandardParameters {
+        /**
+         * The account id
+         */
+        id?: number;
+    }
+    export interface Params$Resource$Accounts$List extends StandardParameters {
+    }
+    export interface Params$Resource$Accounts$Patch extends StandardParameters {
+        /**
+         * The account id
+         */
+        id?: number;
+        /**
+         * Request body metadata
+         */
+        requestBody?: Schema$Account;
+    }
+    export interface Params$Resource$Accounts$Update extends StandardParameters {
+        /**
+         * The account id
+         */
+        id?: number;
+        /**
+         * Request body metadata
+         */
+        requestBody?: Schema$Account;
+    }
+    export class Resource$Creatives {
+        context: APIRequestContext;
+        constructor(context: APIRequestContext);
+        /**
+         * Gets the status for a single creative. A creative will be available 30-40 minutes after submission.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/adexchangebuyer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const adexchangebuyer = google.adexchangebuyer('v1.2');
+         *
+         * 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/adexchange.buyer'],
+         *   });
+         *
+         *   // 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 adexchangebuyer.creatives.get({
+         *     // The id for the account that will serve this creative.
+         *     accountId: 'placeholder-value',
+         *     // The buyer-specific id for this creative.
+         *     buyerCreativeId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "HTMLSnippet": "my_HTMLSnippet",
+         *   //   "accountId": 0,
+         *   //   "advertiserId": [],
+         *   //   "advertiserName": "my_advertiserName",
+         *   //   "agencyId": "my_agencyId",
+         *   //   "apiUploadTimestamp": "my_apiUploadTimestamp",
+         *   //   "attribute": [],
+         *   //   "buyerCreativeId": "my_buyerCreativeId",
+         *   //   "clickThroughUrl": [],
+         *   //   "corrections": [],
+         *   //   "disapprovalReasons": [],
+         *   //   "filteringReasons": {},
+         *   //   "height": 0,
+         *   //   "impressionTrackingUrl": [],
+         *   //   "kind": "my_kind",
+         *   //   "productCategories": [],
+         *   //   "restrictedCategories": [],
+         *   //   "sensitiveCategories": [],
+         *   //   "status": "my_status",
+         *   //   "vendorType": [],
+         *   //   "version": 0,
+         *   //   "videoURL": "my_videoURL",
+         *   //   "width": 0
+         *   // }
+         * }
+         *
+         * 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$Creatives$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        get(params?: Params$Resource$Creatives$Get, options?: MethodOptions): GaxiosPromise<Schema$Creative>;
+        get(params: Params$Resource$Creatives$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        get(params: Params$Resource$Creatives$Get, options: MethodOptions | BodyResponseCallback<Schema$Creative>, callback: BodyResponseCallback<Schema$Creative>): void;
+        get(params: Params$Resource$Creatives$Get, callback: BodyResponseCallback<Schema$Creative>): void;
+        get(callback: BodyResponseCallback<Schema$Creative>): void;
+        /**
+         * Submit a new creative.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/adexchangebuyer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const adexchangebuyer = google.adexchangebuyer('v1.2');
+         *
+         * 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/adexchange.buyer'],
+         *   });
+         *
+         *   // 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 adexchangebuyer.creatives.insert({
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "HTMLSnippet": "my_HTMLSnippet",
+         *       //   "accountId": 0,
+         *       //   "advertiserId": [],
+         *       //   "advertiserName": "my_advertiserName",
+         *       //   "agencyId": "my_agencyId",
+         *       //   "apiUploadTimestamp": "my_apiUploadTimestamp",
+         *       //   "attribute": [],
+         *       //   "buyerCreativeId": "my_buyerCreativeId",
+         *       //   "clickThroughUrl": [],
+         *       //   "corrections": [],
+         *       //   "disapprovalReasons": [],
+         *       //   "filteringReasons": {},
+         *       //   "height": 0,
+         *       //   "impressionTrackingUrl": [],
+         *       //   "kind": "my_kind",
+         *       //   "productCategories": [],
+         *       //   "restrictedCategories": [],
+         *       //   "sensitiveCategories": [],
+         *       //   "status": "my_status",
+         *       //   "vendorType": [],
+         *       //   "version": 0,
+         *       //   "videoURL": "my_videoURL",
+         *       //   "width": 0
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "HTMLSnippet": "my_HTMLSnippet",
+         *   //   "accountId": 0,
+         *   //   "advertiserId": [],
+         *   //   "advertiserName": "my_advertiserName",
+         *   //   "agencyId": "my_agencyId",
+         *   //   "apiUploadTimestamp": "my_apiUploadTimestamp",
+         *   //   "attribute": [],
+         *   //   "buyerCreativeId": "my_buyerCreativeId",
+         *   //   "clickThroughUrl": [],
+         *   //   "corrections": [],
+         *   //   "disapprovalReasons": [],
+         *   //   "filteringReasons": {},
+         *   //   "height": 0,
+         *   //   "impressionTrackingUrl": [],
+         *   //   "kind": "my_kind",
+         *   //   "productCategories": [],
+         *   //   "restrictedCategories": [],
+         *   //   "sensitiveCategories": [],
+         *   //   "status": "my_status",
+         *   //   "vendorType": [],
+         *   //   "version": 0,
+         *   //   "videoURL": "my_videoURL",
+         *   //   "width": 0
+         *   // }
+         * }
+         *
+         * 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.
+         */
+        insert(params: Params$Resource$Creatives$Insert, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        insert(params?: Params$Resource$Creatives$Insert, options?: MethodOptions): GaxiosPromise<Schema$Creative>;
+        insert(params: Params$Resource$Creatives$Insert, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        insert(params: Params$Resource$Creatives$Insert, options: MethodOptions | BodyResponseCallback<Schema$Creative>, callback: BodyResponseCallback<Schema$Creative>): void;
+        insert(params: Params$Resource$Creatives$Insert, callback: BodyResponseCallback<Schema$Creative>): void;
+        insert(callback: BodyResponseCallback<Schema$Creative>): void;
+        /**
+         * Retrieves a list of the authenticated user's active creatives. A creative will be available 30-40 minutes after submission.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/adexchangebuyer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const adexchangebuyer = google.adexchangebuyer('v1.2');
+         *
+         * 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/adexchange.buyer'],
+         *   });
+         *
+         *   // 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 adexchangebuyer.creatives.list({
+         *     // Maximum number of entries returned on one result page. If not set, the default is 100. Optional.
+         *     maxResults: 'placeholder-value',
+         *     // A continuation token, used to page through ad clients. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. Optional.
+         *     pageToken: 'placeholder-value',
+         *     // When specified, only creatives having the given status are returned.
+         *     statusFilter: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "items": [],
+         *   //   "kind": "my_kind",
+         *   //   "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$Creatives$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        list(params?: Params$Resource$Creatives$List, options?: MethodOptions): GaxiosPromise<Schema$CreativesList>;
+        list(params: Params$Resource$Creatives$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        list(params: Params$Resource$Creatives$List, options: MethodOptions | BodyResponseCallback<Schema$CreativesList>, callback: BodyResponseCallback<Schema$CreativesList>): void;
+        list(params: Params$Resource$Creatives$List, callback: BodyResponseCallback<Schema$CreativesList>): void;
+        list(callback: BodyResponseCallback<Schema$CreativesList>): void;
+    }
+    export interface Params$Resource$Creatives$Get extends StandardParameters {
+        /**
+         * The id for the account that will serve this creative.
+         */
+        accountId?: number;
+        /**
+         * The buyer-specific id for this creative.
+         */
+        buyerCreativeId?: string;
+    }
+    export interface Params$Resource$Creatives$Insert extends StandardParameters {
+        /**
+         * Request body metadata
+         */
+        requestBody?: Schema$Creative;
+    }
+    export interface Params$Resource$Creatives$List extends StandardParameters {
+        /**
+         * Maximum number of entries returned on one result page. If not set, the default is 100. Optional.
+         */
+        maxResults?: number;
+        /**
+         * A continuation token, used to page through ad clients. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. Optional.
+         */
+        pageToken?: string;
+        /**
+         * When specified, only creatives having the given status are returned.
+         */
+        statusFilter?: string;
+    }
+    export {};
+}

node_modules/googleapis/build/src/apis/adexchangebuyer2/index.d.ts

@@ -0,0 +1,12 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { adexchangebuyer2_v2beta1 } from './v2beta1';
+export declare const VERSIONS: {
+    v2beta1: typeof adexchangebuyer2_v2beta1.Adexchangebuyer2;
+};
+export declare function adexchangebuyer2(version: 'v2beta1'): adexchangebuyer2_v2beta1.Adexchangebuyer2;
+export declare function adexchangebuyer2(options: adexchangebuyer2_v2beta1.Options): adexchangebuyer2_v2beta1.Adexchangebuyer2;
+declare const auth: AuthPlus;
+export { auth };
+export { adexchangebuyer2_v2beta1 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/adexperiencereport/index.d.ts

@@ -0,0 +1,12 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { adexperiencereport_v1 } from './v1';
+export declare const VERSIONS: {
+    v1: typeof adexperiencereport_v1.Adexperiencereport;
+};
+export declare function adexperiencereport(version: 'v1'): adexperiencereport_v1.Adexperiencereport;
+export declare function adexperiencereport(options: adexperiencereport_v1.Options): adexperiencereport_v1.Adexperiencereport;
+declare const auth: AuthPlus;
+export { auth };
+export { adexperiencereport_v1 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/adexperiencereport/v1.d.ts

@@ -0,0 +1,262 @@
+/// <reference types="node" />
+import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosPromise, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
+import { Readable } from 'stream';
+export declare namespace adexperiencereport_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;
+    }
+    /**
+     * Ad Experience Report API
+     *
+     * Views Ad Experience Report data, and gets a list of sites that have a significant number of annoying ads.
+     *
+     * @example
+     * ```js
+     * const {google} = require('googleapis');
+     * const adexperiencereport = google.adexperiencereport('v1');
+     * ```
+     */
+    export class Adexperiencereport {
+        context: APIRequestContext;
+        sites: Resource$Sites;
+        violatingSites: Resource$Violatingsites;
+        constructor(options: GlobalOptions, google?: GoogleConfigurable);
+    }
+    /**
+     * A site's Ad Experience Report summary on a single platform.
+     */
+    export interface Schema$PlatformSummary {
+        /**
+         * The site's Ad Experience Report status on this platform.
+         */
+        betterAdsStatus?: string | null;
+        /**
+         * The time at which [enforcement](https://support.google.com/webtools/answer/7308033) against the site began or will begin on this platform. Not set when the filter_status is OFF.
+         */
+        enforcementTime?: string | null;
+        /**
+         * The site's [enforcement status](https://support.google.com/webtools/answer/7308033) on this platform.
+         */
+        filterStatus?: string | null;
+        /**
+         * The time at which the site's status last changed on this platform.
+         */
+        lastChangeTime?: string | null;
+        /**
+         * The site's regions on this platform. No longer populated, because there is no longer any semantic difference between sites in different regions.
+         */
+        region?: string[] | null;
+        /**
+         * A link to the full Ad Experience Report for the site on this platform.. Not set in ViolatingSitesResponse. Note that you must complete the [Search Console verification process](https://support.google.com/webmasters/answer/9008080) for the site before you can access the full report.
+         */
+        reportUrl?: string | null;
+        /**
+         * Whether the site is currently under review on this platform.
+         */
+        underReview?: boolean | null;
+    }
+    /**
+     * Response message for GetSiteSummary.
+     */
+    export interface Schema$SiteSummaryResponse {
+        /**
+         * The site's Ad Experience Report summary on desktop.
+         */
+        desktopSummary?: Schema$PlatformSummary;
+        /**
+         * The site's Ad Experience Report summary on mobile.
+         */
+        mobileSummary?: Schema$PlatformSummary;
+        /**
+         * The name of the reviewed site, e.g. `google.com`.
+         */
+        reviewedSite?: string | null;
+    }
+    /**
+     * Response message for ListViolatingSites.
+     */
+    export interface Schema$ViolatingSitesResponse {
+        /**
+         * The list of violating sites.
+         */
+        violatingSites?: Schema$SiteSummaryResponse[];
+    }
+    export class Resource$Sites {
+        context: APIRequestContext;
+        constructor(context: APIRequestContext);
+        /**
+         * Gets a site's Ad Experience Report summary.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/adexperiencereport.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const adexperiencereport = google.adexperiencereport('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: [],
+         *   });
+         *
+         *   // 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 adexperiencereport.sites.get({
+         *     // Required. The name of the site whose summary to get, e.g. `sites/http%3A%2F%2Fwww.google.com%2F`. Format: `sites/{site\}`
+         *     name: 'sites/my-site',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "desktopSummary": {},
+         *   //   "mobileSummary": {},
+         *   //   "reviewedSite": "my_reviewedSite"
+         *   // }
+         * }
+         *
+         * 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$Sites$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        get(params?: Params$Resource$Sites$Get, options?: MethodOptions): GaxiosPromise<Schema$SiteSummaryResponse>;
+        get(params: Params$Resource$Sites$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        get(params: Params$Resource$Sites$Get, options: MethodOptions | BodyResponseCallback<Schema$SiteSummaryResponse>, callback: BodyResponseCallback<Schema$SiteSummaryResponse>): void;
+        get(params: Params$Resource$Sites$Get, callback: BodyResponseCallback<Schema$SiteSummaryResponse>): void;
+        get(callback: BodyResponseCallback<Schema$SiteSummaryResponse>): void;
+    }
+    export interface Params$Resource$Sites$Get extends StandardParameters {
+        /**
+         * Required. The name of the site whose summary to get, e.g. `sites/http%3A%2F%2Fwww.google.com%2F`. Format: `sites/{site\}`
+         */
+        name?: string;
+    }
+    export class Resource$Violatingsites {
+        context: APIRequestContext;
+        constructor(context: APIRequestContext);
+        /**
+         * Lists sites that are failing in the Ad Experience Report on at least one platform.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/adexperiencereport.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const adexperiencereport = google.adexperiencereport('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: [],
+         *   });
+         *
+         *   // 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 adexperiencereport.violatingSites.list({});
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "violatingSites": []
+         *   // }
+         * }
+         *
+         * 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$Violatingsites$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        list(params?: Params$Resource$Violatingsites$List, options?: MethodOptions): GaxiosPromise<Schema$ViolatingSitesResponse>;
+        list(params: Params$Resource$Violatingsites$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        list(params: Params$Resource$Violatingsites$List, options: MethodOptions | BodyResponseCallback<Schema$ViolatingSitesResponse>, callback: BodyResponseCallback<Schema$ViolatingSitesResponse>): void;
+        list(params: Params$Resource$Violatingsites$List, callback: BodyResponseCallback<Schema$ViolatingSitesResponse>): void;
+        list(callback: BodyResponseCallback<Schema$ViolatingSitesResponse>): void;
+    }
+    export interface Params$Resource$Violatingsites$List extends StandardParameters {
+    }
+    export {};
+}

node_modules/googleapis/build/src/apis/admin/datatransfer_v1.d.ts

@@ -0,0 +1,618 @@
+/// <reference types="node" />
+import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosPromise, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
+import { Readable } from 'stream';
+export declare namespace admin_datatransfer_v1 {
+    export interface Options extends GlobalOptions {
+        version: 'datatransfer_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;
+    }
+    /**
+     * Admin SDK API
+     *
+     * Admin SDK lets administrators of enterprise domains to view and manage resources like user, groups etc. It also provides audit and usage reports of domain.
+     *
+     * @example
+     * ```js
+     * const {google} = require('googleapis');
+     * const admin = google.admin('datatransfer_v1');
+     * ```
+     */
+    export class Admin {
+        context: APIRequestContext;
+        applications: Resource$Applications;
+        transfers: Resource$Transfers;
+        constructor(options: GlobalOptions, google?: GoogleConfigurable);
+    }
+    /**
+     * Applications resources represent applications installed on the domain that support transferring ownership of user data.
+     */
+    export interface Schema$Application {
+        /**
+         * Etag of the resource.
+         */
+        etag?: string | null;
+        /**
+         * The application's ID.
+         */
+        id?: string | null;
+        /**
+         * Identifies the resource as a DataTransfer Application Resource.
+         */
+        kind?: string | null;
+        /**
+         * The application's name.
+         */
+        name?: string | null;
+        /**
+         * The list of all possible transfer parameters for this application. These parameters can be used to select the data of the user in this application to be transferred.
+         */
+        transferParams?: Schema$ApplicationTransferParam[];
+    }
+    /**
+     * Template to map fields of ApplicationDataTransfer resource.
+     */
+    export interface Schema$ApplicationDataTransfer {
+        /**
+         * The application's ID.
+         */
+        applicationId?: string | null;
+        /**
+         * The transfer parameters for the application. These parameters are used to select the data which will get transferred in context of this application.
+         */
+        applicationTransferParams?: Schema$ApplicationTransferParam[];
+        /**
+         * Current status of transfer for this application. (Read-only)
+         */
+        applicationTransferStatus?: string | null;
+    }
+    /**
+     * Template for a collection of Applications.
+     */
+    export interface Schema$ApplicationsListResponse {
+        /**
+         * List of applications that support data transfer and are also installed for the customer.
+         */
+        applications?: Schema$Application[];
+        /**
+         * ETag of the resource.
+         */
+        etag?: string | null;
+        /**
+         * Identifies the resource as a collection of Applications.
+         */
+        kind?: string | null;
+        /**
+         * Continuation token which will be used to specify next page in list API.
+         */
+        nextPageToken?: string | null;
+    }
+    /**
+     * Template for application transfer parameters.
+     */
+    export interface Schema$ApplicationTransferParam {
+        /**
+         * The type of the transfer parameter. eg: 'PRIVACY_LEVEL'
+         */
+        key?: string | null;
+        /**
+         * The value of the corresponding transfer parameter. eg: 'PRIVATE' or 'SHARED'
+         */
+        value?: string[] | null;
+    }
+    /**
+     * A Transfer resource represents the transfer of the ownership of user data between users.
+     */
+    export interface Schema$DataTransfer {
+        /**
+         * List of per application data transfer resources. It contains data transfer details of the applications associated with this transfer resource. Note that this list is also used to specify the applications for which data transfer has to be done at the time of the transfer resource creation.
+         */
+        applicationDataTransfers?: Schema$ApplicationDataTransfer[];
+        /**
+         * ETag of the resource.
+         */
+        etag?: string | null;
+        /**
+         * The transfer's ID (Read-only).
+         */
+        id?: string | null;
+        /**
+         * Identifies the resource as a DataTransfer request.
+         */
+        kind?: string | null;
+        /**
+         * ID of the user to whom the data is being transferred.
+         */
+        newOwnerUserId?: string | null;
+        /**
+         * ID of the user whose data is being transferred.
+         */
+        oldOwnerUserId?: string | null;
+        /**
+         * Overall transfer status (Read-only).
+         */
+        overallTransferStatusCode?: string | null;
+        /**
+         * The time at which the data transfer was requested (Read-only).
+         */
+        requestTime?: string | null;
+    }
+    /**
+     * Template for a collection of DataTransfer resources.
+     */
+    export interface Schema$DataTransfersListResponse {
+        /**
+         * List of data transfer requests.
+         */
+        dataTransfers?: Schema$DataTransfer[];
+        /**
+         * ETag of the resource.
+         */
+        etag?: string | null;
+        /**
+         * Identifies the resource as a collection of data transfer requests.
+         */
+        kind?: string | null;
+        /**
+         * Continuation token which will be used to specify next page in list API.
+         */
+        nextPageToken?: string | null;
+    }
+    export class Resource$Applications {
+        context: APIRequestContext;
+        constructor(context: APIRequestContext);
+        /**
+         * Retrieves information about an application for the given application ID.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/admin.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const admin = google.admin('datatransfer_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/admin.datatransfer',
+         *       'https://www.googleapis.com/auth/admin.datatransfer.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 datatransfer.applications.get({
+         *     // ID of the application resource to be retrieved.
+         *     applicationId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "etag": "my_etag",
+         *   //   "id": "my_id",
+         *   //   "kind": "my_kind",
+         *   //   "name": "my_name",
+         *   //   "transferParams": []
+         *   // }
+         * }
+         *
+         * 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$Applications$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        get(params?: Params$Resource$Applications$Get, options?: MethodOptions): GaxiosPromise<Schema$Application>;
+        get(params: Params$Resource$Applications$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        get(params: Params$Resource$Applications$Get, options: MethodOptions | BodyResponseCallback<Schema$Application>, callback: BodyResponseCallback<Schema$Application>): void;
+        get(params: Params$Resource$Applications$Get, callback: BodyResponseCallback<Schema$Application>): void;
+        get(callback: BodyResponseCallback<Schema$Application>): void;
+        /**
+         * Lists the applications available for data transfer for a customer.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/admin.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const admin = google.admin('datatransfer_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/admin.datatransfer',
+         *       'https://www.googleapis.com/auth/admin.datatransfer.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 datatransfer.applications.list({
+         *     // Immutable ID of the Google Workspace account.
+         *     customerId: 'placeholder-value',
+         *     // Maximum number of results to return. Default is 100.
+         *     maxResults: 'placeholder-value',
+         *     // Token to specify next page in the list.
+         *     pageToken: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "applications": [],
+         *   //   "etag": "my_etag",
+         *   //   "kind": "my_kind",
+         *   //   "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$Applications$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        list(params?: Params$Resource$Applications$List, options?: MethodOptions): GaxiosPromise<Schema$ApplicationsListResponse>;
+        list(params: Params$Resource$Applications$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        list(params: Params$Resource$Applications$List, options: MethodOptions | BodyResponseCallback<Schema$ApplicationsListResponse>, callback: BodyResponseCallback<Schema$ApplicationsListResponse>): void;
+        list(params: Params$Resource$Applications$List, callback: BodyResponseCallback<Schema$ApplicationsListResponse>): void;
+        list(callback: BodyResponseCallback<Schema$ApplicationsListResponse>): void;
+    }
+    export interface Params$Resource$Applications$Get extends StandardParameters {
+        /**
+         * ID of the application resource to be retrieved.
+         */
+        applicationId?: string;
+    }
+    export interface Params$Resource$Applications$List extends StandardParameters {
+        /**
+         * Immutable ID of the Google Workspace account.
+         */
+        customerId?: string;
+        /**
+         * Maximum number of results to return. Default is 100.
+         */
+        maxResults?: number;
+        /**
+         * Token to specify next page in the list.
+         */
+        pageToken?: string;
+    }
+    export class Resource$Transfers {
+        context: APIRequestContext;
+        constructor(context: APIRequestContext);
+        /**
+         * Retrieves a data transfer request by its resource ID.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/admin.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const admin = google.admin('datatransfer_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/admin.datatransfer',
+         *       'https://www.googleapis.com/auth/admin.datatransfer.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 datatransfer.transfers.get({
+         *     // ID of the resource to be retrieved. This is returned in the response from the insert method.
+         *     dataTransferId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "applicationDataTransfers": [],
+         *   //   "etag": "my_etag",
+         *   //   "id": "my_id",
+         *   //   "kind": "my_kind",
+         *   //   "newOwnerUserId": "my_newOwnerUserId",
+         *   //   "oldOwnerUserId": "my_oldOwnerUserId",
+         *   //   "overallTransferStatusCode": "my_overallTransferStatusCode",
+         *   //   "requestTime": "my_requestTime"
+         *   // }
+         * }
+         *
+         * 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$Transfers$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        get(params?: Params$Resource$Transfers$Get, options?: MethodOptions): GaxiosPromise<Schema$DataTransfer>;
+        get(params: Params$Resource$Transfers$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        get(params: Params$Resource$Transfers$Get, options: MethodOptions | BodyResponseCallback<Schema$DataTransfer>, callback: BodyResponseCallback<Schema$DataTransfer>): void;
+        get(params: Params$Resource$Transfers$Get, callback: BodyResponseCallback<Schema$DataTransfer>): void;
+        get(callback: BodyResponseCallback<Schema$DataTransfer>): void;
+        /**
+         * Inserts a data transfer request.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/admin.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const admin = google.admin('datatransfer_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/admin.datatransfer'],
+         *   });
+         *
+         *   // 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 datatransfer.transfers.insert({
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "applicationDataTransfers": [],
+         *       //   "etag": "my_etag",
+         *       //   "id": "my_id",
+         *       //   "kind": "my_kind",
+         *       //   "newOwnerUserId": "my_newOwnerUserId",
+         *       //   "oldOwnerUserId": "my_oldOwnerUserId",
+         *       //   "overallTransferStatusCode": "my_overallTransferStatusCode",
+         *       //   "requestTime": "my_requestTime"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "applicationDataTransfers": [],
+         *   //   "etag": "my_etag",
+         *   //   "id": "my_id",
+         *   //   "kind": "my_kind",
+         *   //   "newOwnerUserId": "my_newOwnerUserId",
+         *   //   "oldOwnerUserId": "my_oldOwnerUserId",
+         *   //   "overallTransferStatusCode": "my_overallTransferStatusCode",
+         *   //   "requestTime": "my_requestTime"
+         *   // }
+         * }
+         *
+         * 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.
+         */
+        insert(params: Params$Resource$Transfers$Insert, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        insert(params?: Params$Resource$Transfers$Insert, options?: MethodOptions): GaxiosPromise<Schema$DataTransfer>;
+        insert(params: Params$Resource$Transfers$Insert, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        insert(params: Params$Resource$Transfers$Insert, options: MethodOptions | BodyResponseCallback<Schema$DataTransfer>, callback: BodyResponseCallback<Schema$DataTransfer>): void;
+        insert(params: Params$Resource$Transfers$Insert, callback: BodyResponseCallback<Schema$DataTransfer>): void;
+        insert(callback: BodyResponseCallback<Schema$DataTransfer>): void;
+        /**
+         * Lists the transfers for a customer by source user, destination user, or status.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/admin.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const admin = google.admin('datatransfer_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/admin.datatransfer',
+         *       'https://www.googleapis.com/auth/admin.datatransfer.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 datatransfer.transfers.list({
+         *     // Immutable ID of the Google Workspace account.
+         *     customerId: 'placeholder-value',
+         *     // Maximum number of results to return. Default is 100.
+         *     maxResults: 'placeholder-value',
+         *     // Destination user's profile ID.
+         *     newOwnerUserId: 'placeholder-value',
+         *     // Source user's profile ID.
+         *     oldOwnerUserId: 'placeholder-value',
+         *     // Token to specify the next page in the list.
+         *     pageToken: 'placeholder-value',
+         *     // Status of the transfer.
+         *     status: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "dataTransfers": [],
+         *   //   "etag": "my_etag",
+         *   //   "kind": "my_kind",
+         *   //   "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$Transfers$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        list(params?: Params$Resource$Transfers$List, options?: MethodOptions): GaxiosPromise<Schema$DataTransfersListResponse>;
+        list(params: Params$Resource$Transfers$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        list(params: Params$Resource$Transfers$List, options: MethodOptions | BodyResponseCallback<Schema$DataTransfersListResponse>, callback: BodyResponseCallback<Schema$DataTransfersListResponse>): void;
+        list(params: Params$Resource$Transfers$List, callback: BodyResponseCallback<Schema$DataTransfersListResponse>): void;
+        list(callback: BodyResponseCallback<Schema$DataTransfersListResponse>): void;
+    }
+    export interface Params$Resource$Transfers$Get extends StandardParameters {
+        /**
+         * ID of the resource to be retrieved. This is returned in the response from the insert method.
+         */
+        dataTransferId?: string;
+    }
+    export interface Params$Resource$Transfers$Insert extends StandardParameters {
+        /**
+         * Request body metadata
+         */
+        requestBody?: Schema$DataTransfer;
+    }
+    export interface Params$Resource$Transfers$List extends StandardParameters {
+        /**
+         * Immutable ID of the Google Workspace account.
+         */
+        customerId?: string;
+        /**
+         * Maximum number of results to return. Default is 100.
+         */
+        maxResults?: number;
+        /**
+         * Destination user's profile ID.
+         */
+        newOwnerUserId?: string;
+        /**
+         * Source user's profile ID.
+         */
+        oldOwnerUserId?: string;
+        /**
+         * Token to specify the next page in the list.
+         */
+        pageToken?: string;
+        /**
+         * Status of the transfer.
+         */
+        status?: string;
+    }
+    export {};
+}

node_modules/googleapis/build/src/apis/admin/index.d.ts

@@ -0,0 +1,22 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { admin_datatransfer_v1 } from './datatransfer_v1';
+import { admin_directory_v1 } from './directory_v1';
+import { admin_reports_v1 } from './reports_v1';
+export declare const VERSIONS: {
+    datatransfer_v1: typeof admin_datatransfer_v1.Admin;
+    directory_v1: typeof admin_directory_v1.Admin;
+    reports_v1: typeof admin_reports_v1.Admin;
+};
+export declare function admin(version: 'datatransfer_v1'): admin_datatransfer_v1.Admin;
+export declare function admin(options: admin_datatransfer_v1.Options): admin_datatransfer_v1.Admin;
+export declare function admin(version: 'directory_v1'): admin_directory_v1.Admin;
+export declare function admin(options: admin_directory_v1.Options): admin_directory_v1.Admin;
+export declare function admin(version: 'reports_v1'): admin_reports_v1.Admin;
+export declare function admin(options: admin_reports_v1.Options): admin_reports_v1.Admin;
+declare const auth: AuthPlus;
+export { auth };
+export { admin_datatransfer_v1 };
+export { admin_directory_v1 };
+export { admin_reports_v1 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/admob/index.d.ts

@@ -0,0 +1,17 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { admob_v1 } from './v1';
+import { admob_v1beta } from './v1beta';
+export declare const VERSIONS: {
+    v1: typeof admob_v1.Admob;
+    v1beta: typeof admob_v1beta.Admob;
+};
+export declare function admob(version: 'v1'): admob_v1.Admob;
+export declare function admob(options: admob_v1.Options): admob_v1.Admob;
+export declare function admob(version: 'v1beta'): admob_v1beta.Admob;
+export declare function admob(options: admob_v1beta.Options): admob_v1beta.Admob;
+declare const auth: AuthPlus;
+export { auth };
+export { admob_v1 };
+export { admob_v1beta };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/adsense/index.d.ts

@@ -0,0 +1,17 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { adsense_v1_4 } from './v1.4';
+import { adsense_v2 } from './v2';
+export declare const VERSIONS: {
+    'v1.4': typeof adsense_v1_4.Adsense;
+    v2: typeof adsense_v2.Adsense;
+};
+export declare function adsense(version: 'v1.4'): adsense_v1_4.Adsense;
+export declare function adsense(options: adsense_v1_4.Options): adsense_v1_4.Adsense;
+export declare function adsense(version: 'v2'): adsense_v2.Adsense;
+export declare function adsense(options: adsense_v2.Options): adsense_v2.Adsense;
+declare const auth: AuthPlus;
+export { auth };
+export { adsense_v1_4 };
+export { adsense_v2 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/adsensehost/index.d.ts

@@ -0,0 +1,12 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { adsensehost_v4_1 } from './v4.1';
+export declare const VERSIONS: {
+    'v4.1': typeof adsensehost_v4_1.Adsensehost;
+};
+export declare function adsensehost(version: 'v4.1'): adsensehost_v4_1.Adsensehost;
+export declare function adsensehost(options: adsensehost_v4_1.Options): adsensehost_v4_1.Adsensehost;
+declare const auth: AuthPlus;
+export { auth };
+export { adsensehost_v4_1 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/alertcenter/index.d.ts

@@ -0,0 +1,12 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { alertcenter_v1beta1 } from './v1beta1';
+export declare const VERSIONS: {
+    v1beta1: typeof alertcenter_v1beta1.Alertcenter;
+};
+export declare function alertcenter(version: 'v1beta1'): alertcenter_v1beta1.Alertcenter;
+export declare function alertcenter(options: alertcenter_v1beta1.Options): alertcenter_v1beta1.Alertcenter;
+declare const auth: AuthPlus;
+export { auth };
+export { alertcenter_v1beta1 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/analytics/index.d.ts

@@ -0,0 +1,12 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { analytics_v3 } from './v3';
+export declare const VERSIONS: {
+    v3: typeof analytics_v3.Analytics;
+};
+export declare function analytics(version: 'v3'): analytics_v3.Analytics;
+export declare function analytics(options: analytics_v3.Options): analytics_v3.Analytics;
+declare const auth: AuthPlus;
+export { auth };
+export { analytics_v3 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/analyticsadmin/index.d.ts

@@ -0,0 +1,12 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { analyticsadmin_v1alpha } from './v1alpha';
+export declare const VERSIONS: {
+    v1alpha: typeof analyticsadmin_v1alpha.Analyticsadmin;
+};
+export declare function analyticsadmin(version: 'v1alpha'): analyticsadmin_v1alpha.Analyticsadmin;
+export declare function analyticsadmin(options: analyticsadmin_v1alpha.Options): analyticsadmin_v1alpha.Analyticsadmin;
+declare const auth: AuthPlus;
+export { auth };
+export { analyticsadmin_v1alpha };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/analyticsdata/index.d.ts

@@ -0,0 +1,17 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { analyticsdata_v1alpha } from './v1alpha';
+import { analyticsdata_v1beta } from './v1beta';
+export declare const VERSIONS: {
+    v1alpha: typeof analyticsdata_v1alpha.Analyticsdata;
+    v1beta: typeof analyticsdata_v1beta.Analyticsdata;
+};
+export declare function analyticsdata(version: 'v1alpha'): analyticsdata_v1alpha.Analyticsdata;
+export declare function analyticsdata(options: analyticsdata_v1alpha.Options): analyticsdata_v1alpha.Analyticsdata;
+export declare function analyticsdata(version: 'v1beta'): analyticsdata_v1beta.Analyticsdata;
+export declare function analyticsdata(options: analyticsdata_v1beta.Options): analyticsdata_v1beta.Analyticsdata;
+declare const auth: AuthPlus;
+export { auth };
+export { analyticsdata_v1alpha };
+export { analyticsdata_v1beta };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/analyticshub/index.d.ts

@@ -0,0 +1,17 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { analyticshub_v1 } from './v1';
+import { analyticshub_v1beta1 } from './v1beta1';
+export declare const VERSIONS: {
+    v1: typeof analyticshub_v1.Analyticshub;
+    v1beta1: typeof analyticshub_v1beta1.Analyticshub;
+};
+export declare function analyticshub(version: 'v1'): analyticshub_v1.Analyticshub;
+export declare function analyticshub(options: analyticshub_v1.Options): analyticshub_v1.Analyticshub;
+export declare function analyticshub(version: 'v1beta1'): analyticshub_v1beta1.Analyticshub;
+export declare function analyticshub(options: analyticshub_v1beta1.Options): analyticshub_v1beta1.Analyticshub;
+declare const auth: AuthPlus;
+export { auth };
+export { analyticshub_v1 };
+export { analyticshub_v1beta1 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/analyticsreporting/index.d.ts

@@ -0,0 +1,12 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { analyticsreporting_v4 } from './v4';
+export declare const VERSIONS: {
+    v4: typeof analyticsreporting_v4.Analyticsreporting;
+};
+export declare function analyticsreporting(version: 'v4'): analyticsreporting_v4.Analyticsreporting;
+export declare function analyticsreporting(options: analyticsreporting_v4.Options): analyticsreporting_v4.Analyticsreporting;
+declare const auth: AuthPlus;
+export { auth };
+export { analyticsreporting_v4 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/androiddeviceprovisioning/index.d.ts

@@ -0,0 +1,12 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { androiddeviceprovisioning_v1 } from './v1';
+export declare const VERSIONS: {
+    v1: typeof androiddeviceprovisioning_v1.Androiddeviceprovisioning;
+};
+export declare function androiddeviceprovisioning(version: 'v1'): androiddeviceprovisioning_v1.Androiddeviceprovisioning;
+export declare function androiddeviceprovisioning(options: androiddeviceprovisioning_v1.Options): androiddeviceprovisioning_v1.Androiddeviceprovisioning;
+declare const auth: AuthPlus;
+export { auth };
+export { androiddeviceprovisioning_v1 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/androidenterprise/index.d.ts

@@ -0,0 +1,12 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { androidenterprise_v1 } from './v1';
+export declare const VERSIONS: {
+    v1: typeof androidenterprise_v1.Androidenterprise;
+};
+export declare function androidenterprise(version: 'v1'): androidenterprise_v1.Androidenterprise;
+export declare function androidenterprise(options: androidenterprise_v1.Options): androidenterprise_v1.Androidenterprise;
+declare const auth: AuthPlus;
+export { auth };
+export { androidenterprise_v1 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/androidmanagement/index.d.ts

@@ -0,0 +1,12 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { androidmanagement_v1 } from './v1';
+export declare const VERSIONS: {
+    v1: typeof androidmanagement_v1.Androidmanagement;
+};
+export declare function androidmanagement(version: 'v1'): androidmanagement_v1.Androidmanagement;
+export declare function androidmanagement(options: androidmanagement_v1.Options): androidmanagement_v1.Androidmanagement;
+declare const auth: AuthPlus;
+export { auth };
+export { androidmanagement_v1 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/androidpublisher/index.d.ts

@@ -0,0 +1,27 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { androidpublisher_v1_1 } from './v1.1';
+import { androidpublisher_v1 } from './v1';
+import { androidpublisher_v2 } from './v2';
+import { androidpublisher_v3 } from './v3';
+export declare const VERSIONS: {
+    'v1.1': typeof androidpublisher_v1_1.Androidpublisher;
+    v1: typeof androidpublisher_v1.Androidpublisher;
+    v2: typeof androidpublisher_v2.Androidpublisher;
+    v3: typeof androidpublisher_v3.Androidpublisher;
+};
+export declare function androidpublisher(version: 'v1.1'): androidpublisher_v1_1.Androidpublisher;
+export declare function androidpublisher(options: androidpublisher_v1_1.Options): androidpublisher_v1_1.Androidpublisher;
+export declare function androidpublisher(version: 'v1'): androidpublisher_v1.Androidpublisher;
+export declare function androidpublisher(options: androidpublisher_v1.Options): androidpublisher_v1.Androidpublisher;
+export declare function androidpublisher(version: 'v2'): androidpublisher_v2.Androidpublisher;
+export declare function androidpublisher(options: androidpublisher_v2.Options): androidpublisher_v2.Androidpublisher;
+export declare function androidpublisher(version: 'v3'): androidpublisher_v3.Androidpublisher;
+export declare function androidpublisher(options: androidpublisher_v3.Options): androidpublisher_v3.Androidpublisher;
+declare const auth: AuthPlus;
+export { auth };
+export { androidpublisher_v1_1 };
+export { androidpublisher_v1 };
+export { androidpublisher_v2 };
+export { androidpublisher_v3 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/androidpublisher/v1.1.d.ts

@@ -0,0 +1,184 @@
+/// <reference types="node" />
+import { OAuth2Client, JWT, Compute, UserRefreshClient, GaxiosPromise, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
+import { Readable } from 'stream';
+export declare namespace androidpublisher_v1_1 {
+    export interface Options extends GlobalOptions {
+        version: 'v1.1';
+    }
+    interface StandardParameters {
+        /**
+         * Auth client or API Key for the request
+         */
+        auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient | GoogleAuth;
+        /**
+         * Data format for the response.
+         */
+        alt?: 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;
+        /**
+         * An opaque string that represents a user for quota purposes. Must not exceed 40 characters.
+         */
+        quotaUser?: string;
+        /**
+         * Deprecated. Please use quotaUser instead.
+         */
+        userIp?: string;
+    }
+    /**
+     * Google Play Developer API
+     *
+     * Accesses Android application developers&#39; Google Play accounts.
+     *
+     * @example
+     * const {google} = require('googleapis');
+     * const androidpublisher = google.androidpublisher('v1.1');
+     *
+     * @namespace androidpublisher
+     * @type {Function}
+     * @version v1.1
+     * @variation v1.1
+     * @param {object=} options Options for Androidpublisher
+     */
+    export class Androidpublisher {
+        context: APIRequestContext;
+        inapppurchases: Resource$Inapppurchases;
+        constructor(options: GlobalOptions, google?: GoogleConfigurable);
+    }
+    /**
+     * An InappPurchase resource indicates the status of a user&#39;s inapp product purchase.
+     */
+    export interface Schema$InappPurchase {
+        /**
+         * The consumption state of the inapp product. Possible values are:   - Yet to be consumed  - Consumed
+         */
+        consumptionState?: number | null;
+        /**
+         * A developer-specified string that contains supplemental information about an order.
+         */
+        developerPayload?: string | null;
+        /**
+         * This kind represents an inappPurchase object in the androidpublisher service.
+         */
+        kind?: string | null;
+        /**
+         * The order id associated with the purchase of the inapp product.
+         */
+        orderId?: string | null;
+        /**
+         * The purchase state of the order. Possible values are:   - Purchased  - Canceled  - Pending
+         */
+        purchaseState?: number | null;
+        /**
+         * The time the product was purchased, in milliseconds since the epoch (Jan 1, 1970).
+         */
+        purchaseTime?: string | null;
+        /**
+         * The type of purchase of the inapp product. This field is only set if this purchase was not made using the standard in-app billing flow. Possible values are:   - Test (i.e. purchased from a license testing account)  - Promo (i.e. purchased using a promo code)  - Rewarded (i.e. from watching a video ad instead of paying)
+         */
+        purchaseType?: number | null;
+    }
+    export class Resource$Inapppurchases {
+        context: APIRequestContext;
+        constructor(context: APIRequestContext);
+        /**
+         * androidpublisher.inapppurchases.get
+         * @desc Checks the purchase and consumption status of an inapp item.
+         * @example
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/androidpublisher.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const androidpublisher = google.androidpublisher('v1.1');
+         *
+         * 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/androidpublisher'],
+         *   });
+         *
+         *   // 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 androidpublisher.inapppurchases.get({
+         *     // The package name of the application the inapp product was sold in (for example, 'com.some.thing').
+         *     packageName: 'placeholder-value',
+         *     // The inapp product SKU (for example, 'com.some.thing.inapp1').
+         *     productId: 'placeholder-value',
+         *     // The token provided to the user's device when the inapp product was purchased.
+         *     token: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "consumptionState": 0,
+         *   //   "developerPayload": "my_developerPayload",
+         *   //   "kind": "my_kind",
+         *   //   "orderId": "my_orderId",
+         *   //   "purchaseState": 0,
+         *   //   "purchaseTime": "my_purchaseTime",
+         *   //   "purchaseType": 0
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * @alias androidpublisher.inapppurchases.get
+         * @memberOf! ()
+         *
+         * @param {object} params Parameters for request
+         * @param {string} params.packageName The package name of the application the inapp product was sold in (for example, 'com.some.thing').
+         * @param {string} params.productId The inapp product SKU (for example, 'com.some.thing.inapp1').
+         * @param {string} params.token The token provided to the user's device when the inapp product was purchased.
+         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @param {callback} callback The callback that handles the response.
+         * @return {object} Request object
+         */
+        get(params: Params$Resource$Inapppurchases$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        get(params?: Params$Resource$Inapppurchases$Get, options?: MethodOptions): GaxiosPromise<Schema$InappPurchase>;
+        get(params: Params$Resource$Inapppurchases$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        get(params: Params$Resource$Inapppurchases$Get, options: MethodOptions | BodyResponseCallback<Schema$InappPurchase>, callback: BodyResponseCallback<Schema$InappPurchase>): void;
+        get(params: Params$Resource$Inapppurchases$Get, callback: BodyResponseCallback<Schema$InappPurchase>): void;
+        get(callback: BodyResponseCallback<Schema$InappPurchase>): void;
+    }
+    export interface Params$Resource$Inapppurchases$Get extends StandardParameters {
+        /**
+         * The package name of the application the inapp product was sold in (for example, 'com.some.thing').
+         */
+        packageName?: string;
+        /**
+         * The inapp product SKU (for example, 'com.some.thing.inapp1').
+         */
+        productId?: string;
+        /**
+         * The token provided to the user's device when the inapp product was purchased.
+         */
+        token?: string;
+    }
+    export {};
+}

node_modules/googleapis/build/src/apis/androidpublisher/v1.d.ts

@@ -0,0 +1,25 @@
+import { GoogleConfigurable, GlobalOptions, APIRequestContext } from 'googleapis-common';
+export declare namespace androidpublisher_v1 {
+    interface Options extends GlobalOptions {
+        version: 'v1';
+    }
+    /**
+     * Google Play Developer API
+     *
+     * Accesses Android application developers' Google Play accounts.
+     *
+     * @example
+     * const {google} = require('googleapis');
+     * const androidpublisher = google.androidpublisher('v1');
+     *
+     * @namespace androidpublisher
+     * @type {Function}
+     * @version v1
+     * @variation v1
+     * @param {object=} options Options for Androidpublisher
+     */
+    class Androidpublisher {
+        context: APIRequestContext;
+        constructor(options: GlobalOptions, google?: GoogleConfigurable);
+    }
+}

node_modules/googleapis/build/src/apis/androidpublisher/v2.d.ts

@@ -0,0 +1,330 @@
+/// <reference types="node" />
+import { OAuth2Client, JWT, Compute, UserRefreshClient, GaxiosPromise, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
+import { Readable } from 'stream';
+export declare namespace androidpublisher_v2 {
+    export interface Options extends GlobalOptions {
+        version: 'v2';
+    }
+    interface StandardParameters {
+        /**
+         * Auth client or API Key for the request
+         */
+        auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient | GoogleAuth;
+        /**
+         * Data format for the response.
+         */
+        alt?: 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;
+        /**
+         * An opaque string that represents a user for quota purposes. Must not exceed 40 characters.
+         */
+        quotaUser?: string;
+        /**
+         * Deprecated. Please use quotaUser instead.
+         */
+        userIp?: string;
+    }
+    /**
+     * Google Play Developer API
+     *
+     * Accesses Android application developers&#39; Google Play accounts.
+     *
+     * @example
+     * const {google} = require('googleapis');
+     * const androidpublisher = google.androidpublisher('v2');
+     *
+     * @namespace androidpublisher
+     * @type {Function}
+     * @version v2
+     * @variation v2
+     * @param {object=} options Options for Androidpublisher
+     */
+    export class Androidpublisher {
+        context: APIRequestContext;
+        purchases: Resource$Purchases;
+        constructor(options: GlobalOptions, google?: GoogleConfigurable);
+    }
+    export interface Schema$PageInfo {
+        resultPerPage?: number | null;
+        startIndex?: number | null;
+        totalResults?: number | null;
+    }
+    /**
+     * A ProductPurchase resource indicates the status of a user&#39;s inapp product purchase.
+     */
+    export interface Schema$ProductPurchase {
+        /**
+         * The consumption state of the inapp product. Possible values are:   - Yet to be consumed  - Consumed
+         */
+        consumptionState?: number | null;
+        /**
+         * A developer-specified string that contains supplemental information about an order.
+         */
+        developerPayload?: string | null;
+        /**
+         * This kind represents an inappPurchase object in the androidpublisher service.
+         */
+        kind?: string | null;
+        /**
+         * The order id associated with the purchase of the inapp product.
+         */
+        orderId?: string | null;
+        /**
+         * The purchase state of the order. Possible values are:   - Purchased  - Canceled  - Pending
+         */
+        purchaseState?: number | null;
+        /**
+         * The time the product was purchased, in milliseconds since the epoch (Jan 1, 1970).
+         */
+        purchaseTimeMillis?: string | null;
+        /**
+         * The type of purchase of the inapp product. This field is only set if this purchase was not made using the standard in-app billing flow. Possible values are:   - Test (i.e. purchased from a license testing account)  - Promo (i.e. purchased using a promo code)  - Rewarded (i.e. from watching a video ad instead of paying)
+         */
+        purchaseType?: number | null;
+    }
+    export interface Schema$TokenPagination {
+        nextPageToken?: string | null;
+        previousPageToken?: string | null;
+    }
+    /**
+     * A VoidedPurchase resource indicates a purchase that was either canceled/refunded/charged-back.
+     */
+    export interface Schema$VoidedPurchase {
+        /**
+         * This kind represents a voided purchase object in the androidpublisher service.
+         */
+        kind?: string | null;
+        /**
+         * The time at which the purchase was made, in milliseconds since the epoch (Jan 1, 1970).
+         */
+        purchaseTimeMillis?: string | null;
+        /**
+         * The token which uniquely identifies a one-time purchase or subscription. To uniquely identify subscription renewals use order_id (available starting from version 3 of the API).
+         */
+        purchaseToken?: string | null;
+        /**
+         * The time at which the purchase was canceled/refunded/charged-back, in milliseconds since the epoch (Jan 1, 1970).
+         */
+        voidedTimeMillis?: string | null;
+    }
+    export interface Schema$VoidedPurchasesListResponse {
+        pageInfo?: Schema$PageInfo;
+        tokenPagination?: Schema$TokenPagination;
+        voidedPurchases?: Schema$VoidedPurchase[];
+    }
+    export class Resource$Purchases {
+        context: APIRequestContext;
+        products: Resource$Purchases$Products;
+        voidedpurchases: Resource$Purchases$Voidedpurchases;
+        constructor(context: APIRequestContext);
+    }
+    export class Resource$Purchases$Products {
+        context: APIRequestContext;
+        constructor(context: APIRequestContext);
+        /**
+         * androidpublisher.purchases.products.get
+         * @desc Checks the purchase and consumption status of an inapp item.
+         * @example
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/androidpublisher.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const androidpublisher = google.androidpublisher('v2');
+         *
+         * 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/androidpublisher'],
+         *   });
+         *
+         *   // 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 androidpublisher.purchases.products.get({
+         *     // The package name of the application the inapp product was sold in (for example, 'com.some.thing').
+         *     packageName: 'placeholder-value',
+         *     // The inapp product SKU (for example, 'com.some.thing.inapp1').
+         *     productId: 'placeholder-value',
+         *     // The token provided to the user's device when the inapp product was purchased.
+         *     token: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "consumptionState": 0,
+         *   //   "developerPayload": "my_developerPayload",
+         *   //   "kind": "my_kind",
+         *   //   "orderId": "my_orderId",
+         *   //   "purchaseState": 0,
+         *   //   "purchaseTimeMillis": "my_purchaseTimeMillis",
+         *   //   "purchaseType": 0
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * @alias androidpublisher.purchases.products.get
+         * @memberOf! ()
+         *
+         * @param {object} params Parameters for request
+         * @param {string} params.packageName The package name of the application the inapp product was sold in (for example, 'com.some.thing').
+         * @param {string} params.productId The inapp product SKU (for example, 'com.some.thing.inapp1').
+         * @param {string} params.token The token provided to the user's device when the inapp product was purchased.
+         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @param {callback} callback The callback that handles the response.
+         * @return {object} Request object
+         */
+        get(params: Params$Resource$Purchases$Products$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        get(params?: Params$Resource$Purchases$Products$Get, options?: MethodOptions): GaxiosPromise<Schema$ProductPurchase>;
+        get(params: Params$Resource$Purchases$Products$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        get(params: Params$Resource$Purchases$Products$Get, options: MethodOptions | BodyResponseCallback<Schema$ProductPurchase>, callback: BodyResponseCallback<Schema$ProductPurchase>): void;
+        get(params: Params$Resource$Purchases$Products$Get, callback: BodyResponseCallback<Schema$ProductPurchase>): void;
+        get(callback: BodyResponseCallback<Schema$ProductPurchase>): void;
+    }
+    export interface Params$Resource$Purchases$Products$Get extends StandardParameters {
+        /**
+         * The package name of the application the inapp product was sold in (for example, 'com.some.thing').
+         */
+        packageName?: string;
+        /**
+         * The inapp product SKU (for example, 'com.some.thing.inapp1').
+         */
+        productId?: string;
+        /**
+         * The token provided to the user's device when the inapp product was purchased.
+         */
+        token?: string;
+    }
+    export class Resource$Purchases$Voidedpurchases {
+        context: APIRequestContext;
+        constructor(context: APIRequestContext);
+        /**
+         * androidpublisher.purchases.voidedpurchases.list
+         * @desc Lists the purchases that were canceled, refunded or charged-back.
+         * @example
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/androidpublisher.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const androidpublisher = google.androidpublisher('v2');
+         *
+         * 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/androidpublisher'],
+         *   });
+         *
+         *   // 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 androidpublisher.purchases.voidedpurchases.list({
+         *     // The time, in milliseconds since the Epoch, of the newest voided purchase that you want to see in the response. The value of this parameter cannot be greater than the current time and is ignored if a pagination token is set. Default value is current time. Note: This filter is applied on the time at which the record is seen as voided by our systems and not the actual voided time returned in the response.
+         *     endTime: 'placeholder-value',
+         *
+         *     maxResults: 'placeholder-value',
+         *     // The package name of the application for which voided purchases need to be returned (for example, 'com.some.thing').
+         *     packageName: 'placeholder-value',
+         *
+         *     startIndex: 'placeholder-value',
+         *     // The time, in milliseconds since the Epoch, of the oldest voided purchase that you want to see in the response. The value of this parameter cannot be older than 30 days and is ignored if a pagination token is set. Default value is current time minus 30 days. Note: This filter is applied on the time at which the record is seen as voided by our systems and not the actual voided time returned in the response.
+         *     startTime: 'placeholder-value',
+         *
+         *     token: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "pageInfo": {},
+         *   //   "tokenPagination": {},
+         *   //   "voidedPurchases": []
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * @alias androidpublisher.purchases.voidedpurchases.list
+         * @memberOf! ()
+         *
+         * @param {object} params Parameters for request
+         * @param {string=} params.endTime The time, in milliseconds since the Epoch, of the newest voided purchase that you want to see in the response. The value of this parameter cannot be greater than the current time and is ignored if a pagination token is set. Default value is current time. Note: This filter is applied on the time at which the record is seen as voided by our systems and not the actual voided time returned in the response.
+         * @param {integer=} params.maxResults
+         * @param {string} params.packageName The package name of the application for which voided purchases need to be returned (for example, 'com.some.thing').
+         * @param {integer=} params.startIndex
+         * @param {string=} params.startTime The time, in milliseconds since the Epoch, of the oldest voided purchase that you want to see in the response. The value of this parameter cannot be older than 30 days and is ignored if a pagination token is set. Default value is current time minus 30 days. Note: This filter is applied on the time at which the record is seen as voided by our systems and not the actual voided time returned in the response.
+         * @param {string=} params.token
+         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @param {callback} callback The callback that handles the response.
+         * @return {object} Request object
+         */
+        list(params: Params$Resource$Purchases$Voidedpurchases$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        list(params?: Params$Resource$Purchases$Voidedpurchases$List, options?: MethodOptions): GaxiosPromise<Schema$VoidedPurchasesListResponse>;
+        list(params: Params$Resource$Purchases$Voidedpurchases$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        list(params: Params$Resource$Purchases$Voidedpurchases$List, options: MethodOptions | BodyResponseCallback<Schema$VoidedPurchasesListResponse>, callback: BodyResponseCallback<Schema$VoidedPurchasesListResponse>): void;
+        list(params: Params$Resource$Purchases$Voidedpurchases$List, callback: BodyResponseCallback<Schema$VoidedPurchasesListResponse>): void;
+        list(callback: BodyResponseCallback<Schema$VoidedPurchasesListResponse>): void;
+    }
+    export interface Params$Resource$Purchases$Voidedpurchases$List extends StandardParameters {
+        /**
+         * The time, in milliseconds since the Epoch, of the newest voided purchase that you want to see in the response. The value of this parameter cannot be greater than the current time and is ignored if a pagination token is set. Default value is current time. Note: This filter is applied on the time at which the record is seen as voided by our systems and not the actual voided time returned in the response.
+         */
+        endTime?: string;
+        /**
+         *
+         */
+        maxResults?: number;
+        /**
+         * The package name of the application for which voided purchases need to be returned (for example, 'com.some.thing').
+         */
+        packageName?: string;
+        /**
+         *
+         */
+        startIndex?: number;
+        /**
+         * The time, in milliseconds since the Epoch, of the oldest voided purchase that you want to see in the response. The value of this parameter cannot be older than 30 days and is ignored if a pagination token is set. Default value is current time minus 30 days. Note: This filter is applied on the time at which the record is seen as voided by our systems and not the actual voided time returned in the response.
+         */
+        startTime?: string;
+        /**
+         *
+         */
+        token?: string;
+    }
+    export {};
+}

node_modules/googleapis/build/src/apis/apigateway/index.d.ts

@@ -0,0 +1,17 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { apigateway_v1 } from './v1';
+import { apigateway_v1beta } from './v1beta';
+export declare const VERSIONS: {
+    v1: typeof apigateway_v1.Apigateway;
+    v1beta: typeof apigateway_v1beta.Apigateway;
+};
+export declare function apigateway(version: 'v1'): apigateway_v1.Apigateway;
+export declare function apigateway(options: apigateway_v1.Options): apigateway_v1.Apigateway;
+export declare function apigateway(version: 'v1beta'): apigateway_v1beta.Apigateway;
+export declare function apigateway(options: apigateway_v1beta.Options): apigateway_v1beta.Apigateway;
+declare const auth: AuthPlus;
+export { auth };
+export { apigateway_v1 };
+export { apigateway_v1beta };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/apigeeregistry/index.d.ts

@@ -0,0 +1,12 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { apigeeregistry_v1 } from './v1';
+export declare const VERSIONS: {
+    v1: typeof apigeeregistry_v1.Apigeeregistry;
+};
+export declare function apigeeregistry(version: 'v1'): apigeeregistry_v1.Apigeeregistry;
+export declare function apigeeregistry(options: apigeeregistry_v1.Options): apigeeregistry_v1.Apigeeregistry;
+declare const auth: AuthPlus;
+export { auth };
+export { apigeeregistry_v1 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/apigeeregistry/index.js

@@ -0,0 +1,30 @@
+"use strict";
+// Copyright 2020 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 });
+exports.AuthPlus = exports.apigeeregistry_v1 = exports.auth = exports.apigeeregistry = exports.VERSIONS = void 0;
+/*! THIS FILE IS AUTO-GENERATED */
+const googleapis_common_1 = require("googleapis-common");
+const v1_1 = require("./v1");
+Object.defineProperty(exports, "apigeeregistry_v1", { enumerable: true, get: function () { return v1_1.apigeeregistry_v1; } });
+exports.VERSIONS = {
+    v1: v1_1.apigeeregistry_v1.Apigeeregistry,
+};
+function apigeeregistry(versionOrOptions) {
+    return (0, googleapis_common_1.getAPI)('apigeeregistry', versionOrOptions, exports.VERSIONS, this);
+}
+exports.apigeeregistry = apigeeregistry;
+const auth = new googleapis_common_1.AuthPlus();
+exports.auth = auth;
+var googleapis_common_2 = require("googleapis-common");
+Object.defineProperty(exports, "AuthPlus", { enumerable: true, get: function () { return googleapis_common_2.AuthPlus; } });

node_modules/googleapis/build/src/apis/apikeys/index.d.ts

@@ -0,0 +1,12 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { apikeys_v2 } from './v2';
+export declare const VERSIONS: {
+    v2: typeof apikeys_v2.Apikeys;
+};
+export declare function apikeys(version: 'v2'): apikeys_v2.Apikeys;
+export declare function apikeys(options: apikeys_v2.Options): apikeys_v2.Apikeys;
+declare const auth: AuthPlus;
+export { auth };
+export { apikeys_v2 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/apikeys/index.js

@@ -0,0 +1,30 @@
+"use strict";
+// Copyright 2020 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 });
+exports.AuthPlus = exports.apikeys_v2 = exports.auth = exports.apikeys = exports.VERSIONS = void 0;
+/*! THIS FILE IS AUTO-GENERATED */
+const googleapis_common_1 = require("googleapis-common");
+const v2_1 = require("./v2");
+Object.defineProperty(exports, "apikeys_v2", { enumerable: true, get: function () { return v2_1.apikeys_v2; } });
+exports.VERSIONS = {
+    v2: v2_1.apikeys_v2.Apikeys,
+};
+function apikeys(versionOrOptions) {
+    return (0, googleapis_common_1.getAPI)('apikeys', versionOrOptions, exports.VERSIONS, this);
+}
+exports.apikeys = apikeys;
+const auth = new googleapis_common_1.AuthPlus();
+exports.auth = auth;
+var googleapis_common_2 = require("googleapis-common");
+Object.defineProperty(exports, "AuthPlus", { enumerable: true, get: function () { return googleapis_common_2.AuthPlus; } });

node_modules/googleapis/build/src/apis/apikeys/v2.js

@@ -0,0 +1,356 @@
+"use strict";
+// Copyright 2020 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 });
+exports.apikeys_v2 = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable no-irregular-whitespace */
+const googleapis_common_1 = require("googleapis-common");
+var apikeys_v2;
+(function (apikeys_v2) {
+    /**
+     * API Keys API
+     *
+     * Manages the API keys associated with developer projects.
+     *
+     * @example
+     * ```js
+     * const {google} = require('googleapis');
+     * const apikeys = google.apikeys('v2');
+     * ```
+     */
+    class Apikeys {
+        constructor(options, google) {
+            this.context = {
+                _options: options || {},
+                google,
+            };
+            this.keys = new Resource$Keys(this.context);
+            this.operations = new Resource$Operations(this.context);
+            this.projects = new Resource$Projects(this.context);
+        }
+    }
+    apikeys_v2.Apikeys = Apikeys;
+    class Resource$Keys {
+        constructor(context) {
+            this.context = context;
+        }
+        lookupKey(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback || {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://apikeys.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v2/keys:lookupKey').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: [],
+                pathParams: [],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    apikeys_v2.Resource$Keys = Resource$Keys;
+    class Resource$Operations {
+        constructor(context) {
+            this.context = context;
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback || {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://apikeys.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v2/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    apikeys_v2.Resource$Operations = Resource$Operations;
+    class Resource$Projects {
+        constructor(context) {
+            this.context = context;
+            this.locations = new Resource$Projects$Locations(this.context);
+        }
+    }
+    apikeys_v2.Resource$Projects = Resource$Projects;
+    class Resource$Projects$Locations {
+        constructor(context) {
+            this.context = context;
+            this.keys = new Resource$Projects$Locations$Keys(this.context);
+        }
+    }
+    apikeys_v2.Resource$Projects$Locations = Resource$Projects$Locations;
+    class Resource$Projects$Locations$Keys {
+        constructor(context) {
+            this.context = context;
+        }
+        create(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://apikeys.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v2/{+parent}/keys').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        delete(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://apikeys.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v2/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'DELETE',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://apikeys.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v2/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        getKeyString(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://apikeys.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v2/{+name}/keyString').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://apikeys.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v2/{+parent}/keys').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        patch(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://apikeys.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v2/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'PATCH',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        undelete(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://apikeys.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v2/{+name}:undelete').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    apikeys_v2.Resource$Projects$Locations$Keys = Resource$Projects$Locations$Keys;
+})(apikeys_v2 = exports.apikeys_v2 || (exports.apikeys_v2 = {}));

node_modules/googleapis/build/src/apis/appengine/index.d.ts

@@ -0,0 +1,22 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { appengine_v1 } from './v1';
+import { appengine_v1alpha } from './v1alpha';
+import { appengine_v1beta } from './v1beta';
+export declare const VERSIONS: {
+    v1: typeof appengine_v1.Appengine;
+    v1alpha: typeof appengine_v1alpha.Appengine;
+    v1beta: typeof appengine_v1beta.Appengine;
+};
+export declare function appengine(version: 'v1'): appengine_v1.Appengine;
+export declare function appengine(options: appengine_v1.Options): appengine_v1.Appengine;
+export declare function appengine(version: 'v1alpha'): appengine_v1alpha.Appengine;
+export declare function appengine(options: appengine_v1alpha.Options): appengine_v1alpha.Appengine;
+export declare function appengine(version: 'v1beta'): appengine_v1beta.Appengine;
+export declare function appengine(options: appengine_v1beta.Options): appengine_v1beta.Appengine;
+declare const auth: AuthPlus;
+export { auth };
+export { appengine_v1 };
+export { appengine_v1alpha };
+export { appengine_v1beta };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/appengine/index.js

@@ -0,0 +1,36 @@
+"use strict";
+// Copyright 2020 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 });
+exports.AuthPlus = exports.appengine_v1beta = exports.appengine_v1alpha = exports.appengine_v1 = exports.auth = exports.appengine = exports.VERSIONS = void 0;
+/*! THIS FILE IS AUTO-GENERATED */
+const googleapis_common_1 = require("googleapis-common");
+const v1_1 = require("./v1");
+Object.defineProperty(exports, "appengine_v1", { enumerable: true, get: function () { return v1_1.appengine_v1; } });
+const v1alpha_1 = require("./v1alpha");
+Object.defineProperty(exports, "appengine_v1alpha", { enumerable: true, get: function () { return v1alpha_1.appengine_v1alpha; } });
+const v1beta_1 = require("./v1beta");
+Object.defineProperty(exports, "appengine_v1beta", { enumerable: true, get: function () { return v1beta_1.appengine_v1beta; } });
+exports.VERSIONS = {
+    v1: v1_1.appengine_v1.Appengine,
+    v1alpha: v1alpha_1.appengine_v1alpha.Appengine,
+    v1beta: v1beta_1.appengine_v1beta.Appengine,
+};
+function appengine(versionOrOptions) {
+    return (0, googleapis_common_1.getAPI)('appengine', versionOrOptions, exports.VERSIONS, this);
+}
+exports.appengine = appengine;
+const auth = new googleapis_common_1.AuthPlus();
+exports.auth = auth;
+var googleapis_common_2 = require("googleapis-common");
+Object.defineProperty(exports, "AuthPlus", { enumerable: true, get: function () { return googleapis_common_2.AuthPlus; } });

node_modules/googleapis/build/src/apis/appengine/v1alpha.js

@@ -0,0 +1,704 @@
+"use strict";
+// Copyright 2020 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 });
+exports.appengine_v1alpha = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable no-irregular-whitespace */
+const googleapis_common_1 = require("googleapis-common");
+var appengine_v1alpha;
+(function (appengine_v1alpha) {
+    /**
+     * App Engine Admin API
+     *
+     * Provisions and manages developers' App Engine applications.
+     *
+     * @example
+     * ```js
+     * const {google} = require('googleapis');
+     * const appengine = google.appengine('v1alpha');
+     * ```
+     */
+    class Appengine {
+        constructor(options, google) {
+            this.context = {
+                _options: options || {},
+                google,
+            };
+            this.apps = new Resource$Apps(this.context);
+            this.projects = new Resource$Projects(this.context);
+        }
+    }
+    appengine_v1alpha.Appengine = Appengine;
+    class Resource$Apps {
+        constructor(context) {
+            this.context = context;
+            this.authorizedCertificates = new Resource$Apps$Authorizedcertificates(this.context);
+            this.authorizedDomains = new Resource$Apps$Authorizeddomains(this.context);
+            this.domainMappings = new Resource$Apps$Domainmappings(this.context);
+            this.locations = new Resource$Apps$Locations(this.context);
+            this.operations = new Resource$Apps$Operations(this.context);
+        }
+    }
+    appengine_v1alpha.Resource$Apps = Resource$Apps;
+    class Resource$Apps$Authorizedcertificates {
+        constructor(context) {
+            this.context = context;
+        }
+        create(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://appengine.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha/apps/{appsId}/authorizedCertificates').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['appsId'],
+                pathParams: ['appsId'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        delete(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://appengine.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl +
+                        '/v1alpha/apps/{appsId}/authorizedCertificates/{authorizedCertificatesId}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'DELETE',
+                }, options),
+                params,
+                requiredParams: ['appsId', 'authorizedCertificatesId'],
+                pathParams: ['appsId', 'authorizedCertificatesId'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://appengine.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl +
+                        '/v1alpha/apps/{appsId}/authorizedCertificates/{authorizedCertificatesId}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['appsId', 'authorizedCertificatesId'],
+                pathParams: ['appsId', 'authorizedCertificatesId'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://appengine.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha/apps/{appsId}/authorizedCertificates').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['appsId'],
+                pathParams: ['appsId'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        patch(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://appengine.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl +
+                        '/v1alpha/apps/{appsId}/authorizedCertificates/{authorizedCertificatesId}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'PATCH',
+                }, options),
+                params,
+                requiredParams: ['appsId', 'authorizedCertificatesId'],
+                pathParams: ['appsId', 'authorizedCertificatesId'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    appengine_v1alpha.Resource$Apps$Authorizedcertificates = Resource$Apps$Authorizedcertificates;
+    class Resource$Apps$Authorizeddomains {
+        constructor(context) {
+            this.context = context;
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://appengine.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha/apps/{appsId}/authorizedDomains').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['appsId'],
+                pathParams: ['appsId'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    appengine_v1alpha.Resource$Apps$Authorizeddomains = Resource$Apps$Authorizeddomains;
+    class Resource$Apps$Domainmappings {
+        constructor(context) {
+            this.context = context;
+        }
+        create(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://appengine.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha/apps/{appsId}/domainMappings').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['appsId'],
+                pathParams: ['appsId'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        delete(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://appengine.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl +
+                        '/v1alpha/apps/{appsId}/domainMappings/{domainMappingsId}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'DELETE',
+                }, options),
+                params,
+                requiredParams: ['appsId', 'domainMappingsId'],
+                pathParams: ['appsId', 'domainMappingsId'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://appengine.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl +
+                        '/v1alpha/apps/{appsId}/domainMappings/{domainMappingsId}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['appsId', 'domainMappingsId'],
+                pathParams: ['appsId', 'domainMappingsId'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://appengine.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha/apps/{appsId}/domainMappings').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['appsId'],
+                pathParams: ['appsId'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        patch(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://appengine.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl +
+                        '/v1alpha/apps/{appsId}/domainMappings/{domainMappingsId}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'PATCH',
+                }, options),
+                params,
+                requiredParams: ['appsId', 'domainMappingsId'],
+                pathParams: ['appsId', 'domainMappingsId'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    appengine_v1alpha.Resource$Apps$Domainmappings = Resource$Apps$Domainmappings;
+    class Resource$Apps$Locations {
+        constructor(context) {
+            this.context = context;
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://appengine.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha/apps/{appsId}/locations/{locationsId}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['appsId', 'locationsId'],
+                pathParams: ['appsId', 'locationsId'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://appengine.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha/apps/{appsId}/locations').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['appsId'],
+                pathParams: ['appsId'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    appengine_v1alpha.Resource$Apps$Locations = Resource$Apps$Locations;
+    class Resource$Apps$Operations {
+        constructor(context) {
+            this.context = context;
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://appengine.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha/apps/{appsId}/operations/{operationsId}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['appsId', 'operationsId'],
+                pathParams: ['appsId', 'operationsId'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://appengine.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha/apps/{appsId}/operations').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['appsId'],
+                pathParams: ['appsId'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    appengine_v1alpha.Resource$Apps$Operations = Resource$Apps$Operations;
+    class Resource$Projects {
+        constructor(context) {
+            this.context = context;
+            this.locations = new Resource$Projects$Locations(this.context);
+        }
+    }
+    appengine_v1alpha.Resource$Projects = Resource$Projects;
+    class Resource$Projects$Locations {
+        constructor(context) {
+            this.context = context;
+            this.operations = new Resource$Projects$Locations$Operations(this.context);
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://appengine.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha/projects/{projectsId}/locations/{locationsId}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['projectsId', 'locationsId'],
+                pathParams: ['locationsId', 'projectsId'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://appengine.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha/projects/{projectsId}/locations').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['projectsId'],
+                pathParams: ['projectsId'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    appengine_v1alpha.Resource$Projects$Locations = Resource$Projects$Locations;
+    class Resource$Projects$Locations$Operations {
+        constructor(context) {
+            this.context = context;
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://appengine.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl +
+                        '/v1alpha/projects/{projectsId}/locations/{locationsId}/operations/{operationsId}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['projectsId', 'locationsId', 'operationsId'],
+                pathParams: ['locationsId', 'operationsId', 'projectsId'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://appengine.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl +
+                        '/v1alpha/projects/{projectsId}/locations/{locationsId}/operations').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['projectsId', 'locationsId'],
+                pathParams: ['locationsId', 'projectsId'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    appengine_v1alpha.Resource$Projects$Locations$Operations = Resource$Projects$Locations$Operations;
+})(appengine_v1alpha = exports.appengine_v1alpha || (exports.appengine_v1alpha = {}));

node_modules/googleapis/build/src/apis/appsactivity/index.d.ts

@@ -0,0 +1,12 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { appsactivity_v1 } from './v1';
+export declare const VERSIONS: {
+    v1: typeof appsactivity_v1.Appsactivity;
+};
+export declare function appsactivity(version: 'v1'): appsactivity_v1.Appsactivity;
+export declare function appsactivity(options: appsactivity_v1.Options): appsactivity_v1.Appsactivity;
+declare const auth: AuthPlus;
+export { auth };
+export { appsactivity_v1 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/appsactivity/index.js

@@ -0,0 +1,30 @@
+"use strict";
+// Copyright 2020 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 });
+exports.AuthPlus = exports.appsactivity_v1 = exports.auth = exports.appsactivity = exports.VERSIONS = void 0;
+/*! THIS FILE IS AUTO-GENERATED */
+const googleapis_common_1 = require("googleapis-common");
+const v1_1 = require("./v1");
+Object.defineProperty(exports, "appsactivity_v1", { enumerable: true, get: function () { return v1_1.appsactivity_v1; } });
+exports.VERSIONS = {
+    v1: v1_1.appsactivity_v1.Appsactivity,
+};
+function appsactivity(versionOrOptions) {
+    return (0, googleapis_common_1.getAPI)('appsactivity', versionOrOptions, exports.VERSIONS, this);
+}
+exports.appsactivity = appsactivity;
+const auth = new googleapis_common_1.AuthPlus();
+exports.auth = auth;
+var googleapis_common_2 = require("googleapis-common");
+Object.defineProperty(exports, "AuthPlus", { enumerable: true, get: function () { return googleapis_common_2.AuthPlus; } });

node_modules/googleapis/build/src/apis/appsactivity/v1.d.ts

@@ -0,0 +1,378 @@
+/// <reference types="node" />
+import { OAuth2Client, JWT, Compute, UserRefreshClient, GaxiosPromise, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
+import { Readable } from 'stream';
+export declare namespace appsactivity_v1 {
+    export interface Options extends GlobalOptions {
+        version: 'v1';
+    }
+    interface StandardParameters {
+        /**
+         * Auth client or API Key for the request
+         */
+        auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient | GoogleAuth;
+        /**
+         * Data format for the response.
+         */
+        alt?: 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;
+        /**
+         * An opaque string that represents a user for quota purposes. Must not exceed 40 characters.
+         */
+        quotaUser?: string;
+        /**
+         * Deprecated. Please use quotaUser instead.
+         */
+        userIp?: string;
+    }
+    /**
+     * Drive Activity API
+     *
+     * Provides a historical view of activity.
+     *
+     * @example
+     * const {google} = require('googleapis');
+     * const appsactivity = google.appsactivity('v1');
+     *
+     * @namespace appsactivity
+     * @type {Function}
+     * @version v1
+     * @variation v1
+     * @param {object=} options Options for Appsactivity
+     */
+    export class Appsactivity {
+        context: APIRequestContext;
+        activities: Resource$Activities;
+        constructor(options: GlobalOptions, google?: GoogleConfigurable);
+    }
+    /**
+     * An Activity resource is a combined view of multiple events. An activity has a list of individual events and a combined view of the common fields among all events.
+     */
+    export interface Schema$Activity {
+        /**
+         * The fields common to all of the singleEvents that make up the Activity.
+         */
+        combinedEvent?: Schema$Event;
+        /**
+         * A list of all the Events that make up the Activity.
+         */
+        singleEvents?: Schema$Event[];
+    }
+    /**
+     * Represents the changes associated with an action taken by a user.
+     */
+    export interface Schema$Event {
+        /**
+         * Additional event types. Some events may have multiple types when multiple actions are part of a single event. For example, creating a document, renaming it, and sharing it may be part of a single file-creation event.
+         */
+        additionalEventTypes?: string[] | null;
+        /**
+         * The time at which the event occurred formatted as Unix time in milliseconds.
+         */
+        eventTimeMillis?: string | null;
+        /**
+         * Whether this event is caused by a user being deleted.
+         */
+        fromUserDeletion?: boolean | null;
+        /**
+         * Extra information for move type events, such as changes in an object&#39;s parents.
+         */
+        move?: Schema$Move;
+        /**
+         * Extra information for permissionChange type events, such as the user or group the new permission applies to.
+         */
+        permissionChanges?: Schema$PermissionChange[];
+        /**
+         * The main type of event that occurred.
+         */
+        primaryEventType?: string | null;
+        /**
+         * Extra information for rename type events, such as the old and new names.
+         */
+        rename?: Schema$Rename;
+        /**
+         * Information specific to the Target object modified by the event.
+         */
+        target?: Schema$Target;
+        /**
+         * Represents the user responsible for the event.
+         */
+        user?: Schema$User;
+    }
+    /**
+     * The response from the list request. Contains a list of activities and a token to retrieve the next page of results.
+     */
+    export interface Schema$ListActivitiesResponse {
+        /**
+         * List of activities.
+         */
+        activities?: Schema$Activity[];
+        /**
+         * Token for the next page of results.
+         */
+        nextPageToken?: string | null;
+    }
+    /**
+     * Contains information about changes in an object&#39;s parents as a result of a move type event.
+     */
+    export interface Schema$Move {
+        /**
+         * The added parent(s).
+         */
+        addedParents?: Schema$Parent[];
+        /**
+         * The removed parent(s).
+         */
+        removedParents?: Schema$Parent[];
+    }
+    /**
+     * Contains information about a parent object. For example, a folder in Drive is a parent for all files within it.
+     */
+    export interface Schema$Parent {
+        /**
+         * The parent&#39;s ID.
+         */
+        id?: string | null;
+        /**
+         * Whether this is the root folder.
+         */
+        isRoot?: boolean | null;
+        /**
+         * The parent&#39;s title.
+         */
+        title?: string | null;
+    }
+    /**
+     * Contains information about the permissions and type of access allowed with regards to a Google Drive object. This is a subset of the fields contained in a corresponding Drive Permissions object.
+     */
+    export interface Schema$Permission {
+        /**
+         * The name of the user or group the permission applies to.
+         */
+        name?: string | null;
+        /**
+         * The ID for this permission. Corresponds to the Drive API&#39;s permission ID returned as part of the Drive Permissions resource.
+         */
+        permissionId?: string | null;
+        /**
+         * Indicates the Google Drive permissions role. The role determines a user&#39;s ability to read, write, or comment on the file.
+         */
+        role?: string | null;
+        /**
+         * Indicates how widely permissions are granted.
+         */
+        type?: string | null;
+        /**
+         * The user&#39;s information if the type is USER.
+         */
+        user?: Schema$User;
+        /**
+         * Whether the permission requires a link to the file.
+         */
+        withLink?: boolean | null;
+    }
+    /**
+     * Contains information about a Drive object&#39;s permissions that changed as a result of a permissionChange type event.
+     */
+    export interface Schema$PermissionChange {
+        /**
+         * Lists all Permission objects added.
+         */
+        addedPermissions?: Schema$Permission[];
+        /**
+         * Lists all Permission objects removed.
+         */
+        removedPermissions?: Schema$Permission[];
+    }
+    /**
+     * Photo information for a user.
+     */
+    export interface Schema$Photo {
+        /**
+         * The URL of the photo.
+         */
+        url?: string | null;
+    }
+    /**
+     * Contains information about a renametype event.
+     */
+    export interface Schema$Rename {
+        /**
+         * The new title.
+         */
+        newTitle?: string | null;
+        /**
+         * The old title.
+         */
+        oldTitle?: string | null;
+    }
+    /**
+     * Information about the object modified by the event.
+     */
+    export interface Schema$Target {
+        /**
+         * The ID of the target. For example, in Google Drive, this is the file or folder ID.
+         */
+        id?: string | null;
+        /**
+         * The MIME type of the target.
+         */
+        mimeType?: string | null;
+        /**
+         * The name of the target. For example, in Google Drive, this is the title of the file.
+         */
+        name?: string | null;
+    }
+    /**
+     * A representation of a user.
+     */
+    export interface Schema$User {
+        /**
+         * A boolean which indicates whether the specified User was deleted. If true, name, photo and permission_id will be omitted.
+         */
+        isDeleted?: boolean | null;
+        /**
+         * Whether the user is the authenticated user.
+         */
+        isMe?: boolean | null;
+        /**
+         * The displayable name of the user.
+         */
+        name?: string | null;
+        /**
+         * The permission ID associated with this user. Equivalent to the Drive API&#39;s permission ID for this user, returned as part of the Drive Permissions resource.
+         */
+        permissionId?: string | null;
+        /**
+         * The profile photo of the user. Not present if the user has no profile photo.
+         */
+        photo?: Schema$Photo;
+    }
+    export class Resource$Activities {
+        context: APIRequestContext;
+        constructor(context: APIRequestContext);
+        /**
+         * appsactivity.activities.list
+         * @desc Returns a list of activities visible to the current logged in user. Visible activities are determined by the visibility settings of the object that was acted on, e.g. Drive files a user can see. An activity is a record of past events. Multiple events may be merged if they are similar. A request is scoped to activities from a given Google service using the source parameter.
+         * @example
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/appsactivity.googleapis.com
+         * // - Login into gcloud by running:
+         * //   `$ gcloud auth application-default login`
+         * // - Install the npm module by running:
+         * //   `$ npm install googleapis`
+         *
+         * const {google} = require('googleapis');
+         * const appsactivity = google.appsactivity('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/activity'],
+         *   });
+         *
+         *   // 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 appsactivity.activities.list({
+         *     // Identifies the Drive folder containing the items for which to return activities.
+         *     'drive.ancestorId': 'placeholder-value',
+         *     // Identifies the Drive item to return activities for.
+         *     'drive.fileId': 'placeholder-value',
+         *     // Indicates the strategy to use when grouping singleEvents items in the associated combinedEvent object.
+         *     groupingStrategy: 'placeholder-value',
+         *     // The maximum number of events to return on a page. The response includes a continuation token if there are more events.
+         *     pageSize: 'placeholder-value',
+         *     // A token to retrieve a specific page of results.
+         *     pageToken: 'placeholder-value',
+         *     // The Google service from which to return activities. Possible values of source are:
+         *     // - drive.google.com
+         *     source: 'placeholder-value',
+         *     // The ID used for ACL checks (does not filter the resulting event list by the assigned value). Use the special value me to indicate the currently authenticated user.
+         *     userId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "activities": [],
+         *   //   "nextPageToken": "my_nextPageToken"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * @alias appsactivity.activities.list
+         * @memberOf! ()
+         *
+         * @param {object=} params Parameters for request
+         * @param {string=} params.drive.ancestorId Identifies the Drive folder containing the items for which to return activities.
+         * @param {string=} params.drive.fileId Identifies the Drive item to return activities for.
+         * @param {string=} params.groupingStrategy Indicates the strategy to use when grouping singleEvents items in the associated combinedEvent object.
+         * @param {integer=} params.pageSize The maximum number of events to return on a page. The response includes a continuation token if there are more events.
+         * @param {string=} params.pageToken A token to retrieve a specific page of results.
+         * @param {string=} params.source The Google service from which to return activities. Possible values of source are:  - drive.google.com
+         * @param {string=} params.userId The ID used for ACL checks (does not filter the resulting event list by the assigned value). Use the special value me to indicate the currently authenticated user.
+         * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @param {callback} callback The callback that handles the response.
+         * @return {object} Request object
+         */
+        list(params: Params$Resource$Activities$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
+        list(params?: Params$Resource$Activities$List, options?: MethodOptions): GaxiosPromise<Schema$ListActivitiesResponse>;
+        list(params: Params$Resource$Activities$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        list(params: Params$Resource$Activities$List, options: MethodOptions | BodyResponseCallback<Schema$ListActivitiesResponse>, callback: BodyResponseCallback<Schema$ListActivitiesResponse>): void;
+        list(params: Params$Resource$Activities$List, callback: BodyResponseCallback<Schema$ListActivitiesResponse>): void;
+        list(callback: BodyResponseCallback<Schema$ListActivitiesResponse>): void;
+    }
+    export interface Params$Resource$Activities$List extends StandardParameters {
+        /**
+         * Identifies the Drive folder containing the items for which to return activities.
+         */
+        'drive.ancestorId'?: string;
+        /**
+         * Identifies the Drive item to return activities for.
+         */
+        'drive.fileId'?: string;
+        /**
+         * Indicates the strategy to use when grouping singleEvents items in the associated combinedEvent object.
+         */
+        groupingStrategy?: string;
+        /**
+         * The maximum number of events to return on a page. The response includes a continuation token if there are more events.
+         */
+        pageSize?: number;
+        /**
+         * A token to retrieve a specific page of results.
+         */
+        pageToken?: string;
+        /**
+         * The Google service from which to return activities. Possible values of source are:  - drive.google.com
+         */
+        source?: string;
+        /**
+         * The ID used for ACL checks (does not filter the resulting event list by the assigned value). Use the special value me to indicate the currently authenticated user.
+         */
+        userId?: string;
+    }
+    export {};
+}

node_modules/googleapis/build/src/apis/appsactivity/v1.js

@@ -0,0 +1,86 @@
+"use strict";
+// Copyright 2020 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 });
+exports.appsactivity_v1 = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/class-name-casing */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable no-irregular-whitespace */
+const googleapis_common_1 = require("googleapis-common");
+var appsactivity_v1;
+(function (appsactivity_v1) {
+    /**
+     * Drive Activity API
+     *
+     * Provides a historical view of activity.
+     *
+     * @example
+     * const {google} = require('googleapis');
+     * const appsactivity = google.appsactivity('v1');
+     *
+     * @namespace appsactivity
+     * @type {Function}
+     * @version v1
+     * @variation v1
+     * @param {object=} options Options for Appsactivity
+     */
+    class Appsactivity {
+        constructor(options, google) {
+            this.context = {
+                _options: options || {},
+                google,
+            };
+            this.activities = new Resource$Activities(this.context);
+        }
+    }
+    appsactivity_v1.Appsactivity = Appsactivity;
+    class Resource$Activities {
+        constructor(context) {
+            this.context = context;
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback || {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/appsactivity/v1/activities').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: [],
+                pathParams: [],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    appsactivity_v1.Resource$Activities = Resource$Activities;
+})(appsactivity_v1 = exports.appsactivity_v1 || (exports.appsactivity_v1 = {}));

node_modules/googleapis/build/src/apis/area120tables/index.d.ts

@@ -0,0 +1,12 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { area120tables_v1alpha1 } from './v1alpha1';
+export declare const VERSIONS: {
+    v1alpha1: typeof area120tables_v1alpha1.Area120tables;
+};
+export declare function area120tables(version: 'v1alpha1'): area120tables_v1alpha1.Area120tables;
+export declare function area120tables(options: area120tables_v1alpha1.Options): area120tables_v1alpha1.Area120tables;
+declare const auth: AuthPlus;
+export { auth };
+export { area120tables_v1alpha1 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/area120tables/index.js

@@ -0,0 +1,30 @@
+"use strict";
+// Copyright 2020 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 });
+exports.AuthPlus = exports.area120tables_v1alpha1 = exports.auth = exports.area120tables = exports.VERSIONS = void 0;
+/*! THIS FILE IS AUTO-GENERATED */
+const googleapis_common_1 = require("googleapis-common");
+const v1alpha1_1 = require("./v1alpha1");
+Object.defineProperty(exports, "area120tables_v1alpha1", { enumerable: true, get: function () { return v1alpha1_1.area120tables_v1alpha1; } });
+exports.VERSIONS = {
+    v1alpha1: v1alpha1_1.area120tables_v1alpha1.Area120tables,
+};
+function area120tables(versionOrOptions) {
+    return (0, googleapis_common_1.getAPI)('area120tables', versionOrOptions, exports.VERSIONS, this);
+}
+exports.area120tables = area120tables;
+const auth = new googleapis_common_1.AuthPlus();
+exports.auth = auth;
+var googleapis_common_2 = require("googleapis-common");
+Object.defineProperty(exports, "AuthPlus", { enumerable: true, get: function () { return googleapis_common_2.AuthPlus; } });

node_modules/googleapis/build/src/apis/area120tables/v1alpha1.js

@@ -0,0 +1,431 @@
+"use strict";
+// Copyright 2020 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 });
+exports.area120tables_v1alpha1 = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable no-irregular-whitespace */
+const googleapis_common_1 = require("googleapis-common");
+var area120tables_v1alpha1;
+(function (area120tables_v1alpha1) {
+    /**
+     * Area120 Tables API
+     *
+     *
+     *
+     * @example
+     * ```js
+     * const {google} = require('googleapis');
+     * const area120tables = google.area120tables('v1alpha1');
+     * ```
+     */
+    class Area120tables {
+        constructor(options, google) {
+            this.context = {
+                _options: options || {},
+                google,
+            };
+            this.tables = new Resource$Tables(this.context);
+            this.workspaces = new Resource$Workspaces(this.context);
+        }
+    }
+    area120tables_v1alpha1.Area120tables = Area120tables;
+    class Resource$Tables {
+        constructor(context) {
+            this.context = context;
+            this.rows = new Resource$Tables$Rows(this.context);
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback || {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://area120tables.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback || {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://area120tables.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha1/tables').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: [],
+                pathParams: [],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    area120tables_v1alpha1.Resource$Tables = Resource$Tables;
+    class Resource$Tables$Rows {
+        constructor(context) {
+            this.context = context;
+        }
+        batchCreate(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://area120tables.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha1/{+parent}/rows:batchCreate').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        batchDelete(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://area120tables.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha1/{+parent}/rows:batchDelete').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        batchUpdate(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://area120tables.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha1/{+parent}/rows:batchUpdate').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        create(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://area120tables.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha1/{+parent}/rows').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        delete(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://area120tables.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'DELETE',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback || {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://area120tables.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback || {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://area120tables.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha1/{+parent}/rows').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        patch(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://area120tables.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'PATCH',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    area120tables_v1alpha1.Resource$Tables$Rows = Resource$Tables$Rows;
+    class Resource$Workspaces {
+        constructor(context) {
+            this.context = context;
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback || {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://area120tables.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback || {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://area120tables.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1alpha1/workspaces').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: [],
+                pathParams: [],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    area120tables_v1alpha1.Resource$Workspaces = Resource$Workspaces;
+})(area120tables_v1alpha1 = exports.area120tables_v1alpha1 || (exports.area120tables_v1alpha1 = {}));

node_modules/googleapis/build/src/apis/artifactregistry/index.d.ts

@@ -0,0 +1,22 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { artifactregistry_v1 } from './v1';
+import { artifactregistry_v1beta1 } from './v1beta1';
+import { artifactregistry_v1beta2 } from './v1beta2';
+export declare const VERSIONS: {
+    v1: typeof artifactregistry_v1.Artifactregistry;
+    v1beta1: typeof artifactregistry_v1beta1.Artifactregistry;
+    v1beta2: typeof artifactregistry_v1beta2.Artifactregistry;
+};
+export declare function artifactregistry(version: 'v1'): artifactregistry_v1.Artifactregistry;
+export declare function artifactregistry(options: artifactregistry_v1.Options): artifactregistry_v1.Artifactregistry;
+export declare function artifactregistry(version: 'v1beta1'): artifactregistry_v1beta1.Artifactregistry;
+export declare function artifactregistry(options: artifactregistry_v1beta1.Options): artifactregistry_v1beta1.Artifactregistry;
+export declare function artifactregistry(version: 'v1beta2'): artifactregistry_v1beta2.Artifactregistry;
+export declare function artifactregistry(options: artifactregistry_v1beta2.Options): artifactregistry_v1beta2.Artifactregistry;
+declare const auth: AuthPlus;
+export { auth };
+export { artifactregistry_v1 };
+export { artifactregistry_v1beta1 };
+export { artifactregistry_v1beta2 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/artifactregistry/index.js

@@ -0,0 +1,36 @@
+"use strict";
+// Copyright 2020 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 });
+exports.AuthPlus = exports.artifactregistry_v1beta2 = exports.artifactregistry_v1beta1 = exports.artifactregistry_v1 = exports.auth = exports.artifactregistry = exports.VERSIONS = void 0;
+/*! THIS FILE IS AUTO-GENERATED */
+const googleapis_common_1 = require("googleapis-common");
+const v1_1 = require("./v1");
+Object.defineProperty(exports, "artifactregistry_v1", { enumerable: true, get: function () { return v1_1.artifactregistry_v1; } });
+const v1beta1_1 = require("./v1beta1");
+Object.defineProperty(exports, "artifactregistry_v1beta1", { enumerable: true, get: function () { return v1beta1_1.artifactregistry_v1beta1; } });
+const v1beta2_1 = require("./v1beta2");
+Object.defineProperty(exports, "artifactregistry_v1beta2", { enumerable: true, get: function () { return v1beta2_1.artifactregistry_v1beta2; } });
+exports.VERSIONS = {
+    v1: v1_1.artifactregistry_v1.Artifactregistry,
+    v1beta1: v1beta1_1.artifactregistry_v1beta1.Artifactregistry,
+    v1beta2: v1beta2_1.artifactregistry_v1beta2.Artifactregistry,
+};
+function artifactregistry(versionOrOptions) {
+    return (0, googleapis_common_1.getAPI)('artifactregistry', versionOrOptions, exports.VERSIONS, this);
+}
+exports.artifactregistry = artifactregistry;
+const auth = new googleapis_common_1.AuthPlus();
+exports.auth = auth;
+var googleapis_common_2 = require("googleapis-common");
+Object.defineProperty(exports, "AuthPlus", { enumerable: true, get: function () { return googleapis_common_2.AuthPlus; } });

node_modules/googleapis/build/src/apis/artifactregistry/v1beta1.js

@@ -0,0 +1,861 @@
+"use strict";
+// Copyright 2020 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 });
+exports.artifactregistry_v1beta1 = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable no-irregular-whitespace */
+const googleapis_common_1 = require("googleapis-common");
+var artifactregistry_v1beta1;
+(function (artifactregistry_v1beta1) {
+    /**
+     * Artifact Registry API
+     *
+     * Store and manage build artifacts in a scalable and integrated service built on Google infrastructure.
+     *
+     * @example
+     * ```js
+     * const {google} = require('googleapis');
+     * const artifactregistry = google.artifactregistry('v1beta1');
+     * ```
+     */
+    class Artifactregistry {
+        constructor(options, google) {
+            this.context = {
+                _options: options || {},
+                google,
+            };
+            this.projects = new Resource$Projects(this.context);
+        }
+    }
+    artifactregistry_v1beta1.Artifactregistry = Artifactregistry;
+    class Resource$Projects {
+        constructor(context) {
+            this.context = context;
+            this.locations = new Resource$Projects$Locations(this.context);
+        }
+    }
+    artifactregistry_v1beta1.Resource$Projects = Resource$Projects;
+    class Resource$Projects$Locations {
+        constructor(context) {
+            this.context = context;
+            this.operations = new Resource$Projects$Locations$Operations(this.context);
+            this.repositories = new Resource$Projects$Locations$Repositories(this.context);
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}/locations').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    artifactregistry_v1beta1.Resource$Projects$Locations = Resource$Projects$Locations;
+    class Resource$Projects$Locations$Operations {
+        constructor(context) {
+            this.context = context;
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    artifactregistry_v1beta1.Resource$Projects$Locations$Operations = Resource$Projects$Locations$Operations;
+    class Resource$Projects$Locations$Repositories {
+        constructor(context) {
+            this.context = context;
+            this.files = new Resource$Projects$Locations$Repositories$Files(this.context);
+            this.packages = new Resource$Projects$Locations$Repositories$Packages(this.context);
+        }
+        create(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+parent}/repositories').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        delete(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'DELETE',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        getIamPolicy(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+resource}:getIamPolicy').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['resource'],
+                pathParams: ['resource'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+parent}/repositories').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        patch(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'PATCH',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        setIamPolicy(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+resource}:setIamPolicy').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['resource'],
+                pathParams: ['resource'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        testIamPermissions(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+resource}:testIamPermissions').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['resource'],
+                pathParams: ['resource'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    artifactregistry_v1beta1.Resource$Projects$Locations$Repositories = Resource$Projects$Locations$Repositories;
+    class Resource$Projects$Locations$Repositories$Files {
+        constructor(context) {
+            this.context = context;
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+parent}/files').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    artifactregistry_v1beta1.Resource$Projects$Locations$Repositories$Files = Resource$Projects$Locations$Repositories$Files;
+    class Resource$Projects$Locations$Repositories$Packages {
+        constructor(context) {
+            this.context = context;
+            this.tags = new Resource$Projects$Locations$Repositories$Packages$Tags(this.context);
+            this.versions =
+                new Resource$Projects$Locations$Repositories$Packages$Versions(this.context);
+        }
+        delete(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'DELETE',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+parent}/packages').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    artifactregistry_v1beta1.Resource$Projects$Locations$Repositories$Packages = Resource$Projects$Locations$Repositories$Packages;
+    class Resource$Projects$Locations$Repositories$Packages$Tags {
+        constructor(context) {
+            this.context = context;
+        }
+        create(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+parent}/tags').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        delete(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'DELETE',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+parent}/tags').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        patch(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'PATCH',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    artifactregistry_v1beta1.Resource$Projects$Locations$Repositories$Packages$Tags = Resource$Projects$Locations$Repositories$Packages$Tags;
+    class Resource$Projects$Locations$Repositories$Packages$Versions {
+        constructor(context) {
+            this.context = context;
+        }
+        delete(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'DELETE',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+parent}/versions').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    artifactregistry_v1beta1.Resource$Projects$Locations$Repositories$Packages$Versions = Resource$Projects$Locations$Repositories$Packages$Versions;
+})(artifactregistry_v1beta1 = exports.artifactregistry_v1beta1 || (exports.artifactregistry_v1beta1 = {}));

node_modules/googleapis/build/src/apis/artifactregistry/v1beta2.js

@@ -0,0 +1,973 @@
+"use strict";
+// Copyright 2020 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 });
+exports.artifactregistry_v1beta2 = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/class-name-casing */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable no-irregular-whitespace */
+const googleapis_common_1 = require("googleapis-common");
+var artifactregistry_v1beta2;
+(function (artifactregistry_v1beta2) {
+    /**
+     * Artifact Registry API
+     *
+     * Store and manage build artifacts in a scalable and integrated service built on Google infrastructure.
+     *
+     * @example
+     * ```js
+     * const {google} = require('googleapis');
+     * const artifactregistry = google.artifactregistry('v1beta2');
+     * ```
+     */
+    class Artifactregistry {
+        constructor(options, google) {
+            this.context = {
+                _options: options || {},
+                google,
+            };
+            this.projects = new Resource$Projects(this.context);
+        }
+    }
+    artifactregistry_v1beta2.Artifactregistry = Artifactregistry;
+    class Resource$Projects {
+        constructor(context) {
+            this.context = context;
+            this.locations = new Resource$Projects$Locations(this.context);
+        }
+    }
+    artifactregistry_v1beta2.Resource$Projects = Resource$Projects;
+    class Resource$Projects$Locations {
+        constructor(context) {
+            this.context = context;
+            this.operations = new Resource$Projects$Locations$Operations(this.context);
+            this.repositories = new Resource$Projects$Locations$Repositories(this.context);
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+name}/locations').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    artifactregistry_v1beta2.Resource$Projects$Locations = Resource$Projects$Locations;
+    class Resource$Projects$Locations$Operations {
+        constructor(context) {
+            this.context = context;
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+name}/operations').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    artifactregistry_v1beta2.Resource$Projects$Locations$Operations = Resource$Projects$Locations$Operations;
+    class Resource$Projects$Locations$Repositories {
+        constructor(context) {
+            this.context = context;
+            this.aptArtifacts =
+                new Resource$Projects$Locations$Repositories$Aptartifacts(this.context);
+            this.files = new Resource$Projects$Locations$Repositories$Files(this.context);
+            this.packages = new Resource$Projects$Locations$Repositories$Packages(this.context);
+            this.yumArtifacts =
+                new Resource$Projects$Locations$Repositories$Yumartifacts(this.context);
+        }
+        create(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+parent}/repositories').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        delete(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'DELETE',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        getIamPolicy(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+resource}:getIamPolicy').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['resource'],
+                pathParams: ['resource'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+parent}/repositories').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        patch(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'PATCH',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        setIamPolicy(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+resource}:setIamPolicy').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['resource'],
+                pathParams: ['resource'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        testIamPermissions(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+resource}:testIamPermissions').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['resource'],
+                pathParams: ['resource'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    artifactregistry_v1beta2.Resource$Projects$Locations$Repositories = Resource$Projects$Locations$Repositories;
+    class Resource$Projects$Locations$Repositories$Aptartifacts {
+        constructor(context) {
+            this.context = context;
+        }
+        import(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+parent}/aptArtifacts:import').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    artifactregistry_v1beta2.Resource$Projects$Locations$Repositories$Aptartifacts = Resource$Projects$Locations$Repositories$Aptartifacts;
+    class Resource$Projects$Locations$Repositories$Files {
+        constructor(context) {
+            this.context = context;
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+parent}/files').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    artifactregistry_v1beta2.Resource$Projects$Locations$Repositories$Files = Resource$Projects$Locations$Repositories$Files;
+    class Resource$Projects$Locations$Repositories$Packages {
+        constructor(context) {
+            this.context = context;
+            this.tags = new Resource$Projects$Locations$Repositories$Packages$Tags(this.context);
+            this.versions =
+                new Resource$Projects$Locations$Repositories$Packages$Versions(this.context);
+        }
+        delete(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'DELETE',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+parent}/packages').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    artifactregistry_v1beta2.Resource$Projects$Locations$Repositories$Packages = Resource$Projects$Locations$Repositories$Packages;
+    class Resource$Projects$Locations$Repositories$Packages$Tags {
+        constructor(context) {
+            this.context = context;
+        }
+        create(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+parent}/tags').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        delete(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'DELETE',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+parent}/tags').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        patch(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'PATCH',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    artifactregistry_v1beta2.Resource$Projects$Locations$Repositories$Packages$Tags = Resource$Projects$Locations$Repositories$Packages$Tags;
+    class Resource$Projects$Locations$Repositories$Packages$Versions {
+        constructor(context) {
+            this.context = context;
+        }
+        delete(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'DELETE',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+parent}/versions').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    artifactregistry_v1beta2.Resource$Projects$Locations$Repositories$Packages$Versions = Resource$Projects$Locations$Repositories$Packages$Versions;
+    class Resource$Projects$Locations$Repositories$Yumartifacts {
+        constructor(context) {
+            this.context = context;
+        }
+        import(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://artifactregistry.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta2/{+parent}/yumArtifacts:import').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    artifactregistry_v1beta2.Resource$Projects$Locations$Repositories$Yumartifacts = Resource$Projects$Locations$Repositories$Yumartifacts;
+})(artifactregistry_v1beta2 = exports.artifactregistry_v1beta2 || (exports.artifactregistry_v1beta2 = {}));

node_modules/googleapis/build/src/apis/assuredworkloads/index.d.ts

@@ -0,0 +1,17 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { assuredworkloads_v1 } from './v1';
+import { assuredworkloads_v1beta1 } from './v1beta1';
+export declare const VERSIONS: {
+    v1: typeof assuredworkloads_v1.Assuredworkloads;
+    v1beta1: typeof assuredworkloads_v1beta1.Assuredworkloads;
+};
+export declare function assuredworkloads(version: 'v1'): assuredworkloads_v1.Assuredworkloads;
+export declare function assuredworkloads(options: assuredworkloads_v1.Options): assuredworkloads_v1.Assuredworkloads;
+export declare function assuredworkloads(version: 'v1beta1'): assuredworkloads_v1beta1.Assuredworkloads;
+export declare function assuredworkloads(options: assuredworkloads_v1beta1.Options): assuredworkloads_v1beta1.Assuredworkloads;
+declare const auth: AuthPlus;
+export { auth };
+export { assuredworkloads_v1 };
+export { assuredworkloads_v1beta1 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';

node_modules/googleapis/build/src/apis/assuredworkloads/index.js

@@ -0,0 +1,33 @@
+"use strict";
+// Copyright 2020 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 });
+exports.AuthPlus = exports.assuredworkloads_v1beta1 = exports.assuredworkloads_v1 = exports.auth = exports.assuredworkloads = exports.VERSIONS = void 0;
+/*! THIS FILE IS AUTO-GENERATED */
+const googleapis_common_1 = require("googleapis-common");
+const v1_1 = require("./v1");
+Object.defineProperty(exports, "assuredworkloads_v1", { enumerable: true, get: function () { return v1_1.assuredworkloads_v1; } });
+const v1beta1_1 = require("./v1beta1");
+Object.defineProperty(exports, "assuredworkloads_v1beta1", { enumerable: true, get: function () { return v1beta1_1.assuredworkloads_v1beta1; } });
+exports.VERSIONS = {
+    v1: v1_1.assuredworkloads_v1.Assuredworkloads,
+    v1beta1: v1beta1_1.assuredworkloads_v1beta1.Assuredworkloads,
+};
+function assuredworkloads(versionOrOptions) {
+    return (0, googleapis_common_1.getAPI)('assuredworkloads', versionOrOptions, exports.VERSIONS, this);
+}
+exports.assuredworkloads = assuredworkloads;
+const auth = new googleapis_common_1.AuthPlus();
+exports.auth = auth;
+var googleapis_common_2 = require("googleapis-common");
+Object.defineProperty(exports, "AuthPlus", { enumerable: true, get: function () { return googleapis_common_2.AuthPlus; } });

node_modules/googleapis/build/src/apis/assuredworkloads/v1.js

@@ -0,0 +1,425 @@
+"use strict";
+// Copyright 2020 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 });
+exports.assuredworkloads_v1 = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable no-irregular-whitespace */
+const googleapis_common_1 = require("googleapis-common");
+var assuredworkloads_v1;
+(function (assuredworkloads_v1) {
+    /**
+     * Assured Workloads API
+     *
+     *
+     *
+     * @example
+     * ```js
+     * const {google} = require('googleapis');
+     * const assuredworkloads = google.assuredworkloads('v1');
+     * ```
+     */
+    class Assuredworkloads {
+        constructor(options, google) {
+            this.context = {
+                _options: options || {},
+                google,
+            };
+            this.organizations = new Resource$Organizations(this.context);
+        }
+    }
+    assuredworkloads_v1.Assuredworkloads = Assuredworkloads;
+    class Resource$Organizations {
+        constructor(context) {
+            this.context = context;
+            this.locations = new Resource$Organizations$Locations(this.context);
+        }
+    }
+    assuredworkloads_v1.Resource$Organizations = Resource$Organizations;
+    class Resource$Organizations$Locations {
+        constructor(context) {
+            this.context = context;
+            this.operations = new Resource$Organizations$Locations$Operations(this.context);
+            this.workloads = new Resource$Organizations$Locations$Workloads(this.context);
+        }
+    }
+    assuredworkloads_v1.Resource$Organizations$Locations = Resource$Organizations$Locations;
+    class Resource$Organizations$Locations$Operations {
+        constructor(context) {
+            this.context = context;
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1/{+name}/operations').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    assuredworkloads_v1.Resource$Organizations$Locations$Operations = Resource$Organizations$Locations$Operations;
+    class Resource$Organizations$Locations$Workloads {
+        constructor(context) {
+            this.context = context;
+            this.violations =
+                new Resource$Organizations$Locations$Workloads$Violations(this.context);
+        }
+        create(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1/{+parent}/workloads').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        delete(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'DELETE',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1/{+parent}/workloads').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        patch(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'PATCH',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        restrictAllowedResources(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1/{+name}:restrictAllowedResources').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    assuredworkloads_v1.Resource$Organizations$Locations$Workloads = Resource$Organizations$Locations$Workloads;
+    class Resource$Organizations$Locations$Workloads$Violations {
+        constructor(context) {
+            this.context = context;
+        }
+        acknowledge(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1/{+name}:acknowledge').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1/{+parent}/violations').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    assuredworkloads_v1.Resource$Organizations$Locations$Workloads$Violations = Resource$Organizations$Locations$Workloads$Violations;
+})(assuredworkloads_v1 = exports.assuredworkloads_v1 || (exports.assuredworkloads_v1 = {}));

node_modules/googleapis/build/src/apis/assuredworkloads/v1beta1.js

@@ -0,0 +1,541 @@
+"use strict";
+// Copyright 2020 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 });
+exports.assuredworkloads_v1beta1 = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable no-irregular-whitespace */
+const googleapis_common_1 = require("googleapis-common");
+var assuredworkloads_v1beta1;
+(function (assuredworkloads_v1beta1) {
+    /**
+     * Assured Workloads API
+     *
+     *
+     *
+     * @example
+     * ```js
+     * const {google} = require('googleapis');
+     * const assuredworkloads = google.assuredworkloads('v1beta1');
+     * ```
+     */
+    class Assuredworkloads {
+        constructor(options, google) {
+            this.context = {
+                _options: options || {},
+                google,
+            };
+            this.organizations = new Resource$Organizations(this.context);
+            this.projects = new Resource$Projects(this.context);
+        }
+    }
+    assuredworkloads_v1beta1.Assuredworkloads = Assuredworkloads;
+    class Resource$Organizations {
+        constructor(context) {
+            this.context = context;
+            this.locations = new Resource$Organizations$Locations(this.context);
+        }
+    }
+    assuredworkloads_v1beta1.Resource$Organizations = Resource$Organizations;
+    class Resource$Organizations$Locations {
+        constructor(context) {
+            this.context = context;
+            this.operations = new Resource$Organizations$Locations$Operations(this.context);
+            this.workloads = new Resource$Organizations$Locations$Workloads(this.context);
+        }
+    }
+    assuredworkloads_v1beta1.Resource$Organizations$Locations = Resource$Organizations$Locations;
+    class Resource$Organizations$Locations$Operations {
+        constructor(context) {
+            this.context = context;
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}/operations').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    assuredworkloads_v1beta1.Resource$Organizations$Locations$Operations = Resource$Organizations$Locations$Operations;
+    class Resource$Organizations$Locations$Workloads {
+        constructor(context) {
+            this.context = context;
+            this.organizations =
+                new Resource$Organizations$Locations$Workloads$Organizations(this.context);
+            this.violations =
+                new Resource$Organizations$Locations$Workloads$Violations(this.context);
+        }
+        create(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+parent}/workloads').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        delete(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'DELETE',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+parent}/workloads').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        patch(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params = {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'PATCH',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        restrictAllowedResources(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}:restrictAllowedResources').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    assuredworkloads_v1beta1.Resource$Organizations$Locations$Workloads = Resource$Organizations$Locations$Workloads;
+    class Resource$Organizations$Locations$Workloads$Organizations {
+        constructor(context) {
+            this.context = context;
+            this.locations =
+                new Resource$Organizations$Locations$Workloads$Organizations$Locations(this.context);
+        }
+    }
+    assuredworkloads_v1beta1.Resource$Organizations$Locations$Workloads$Organizations = Resource$Organizations$Locations$Workloads$Organizations;
+    class Resource$Organizations$Locations$Workloads$Organizations$Locations {
+        constructor(context) {
+            this.context = context;
+            this.workloads =
+                new Resource$Organizations$Locations$Workloads$Organizations$Locations$Workloads(this.context);
+        }
+    }
+    assuredworkloads_v1beta1.Resource$Organizations$Locations$Workloads$Organizations$Locations = Resource$Organizations$Locations$Workloads$Organizations$Locations;
+    class Resource$Organizations$Locations$Workloads$Organizations$Locations$Workloads {
+        constructor(context) {
+            this.context = context;
+        }
+        analyzeWorkloadMove(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+source}/{+target}:analyzeWorkloadMove').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['source', 'target'],
+                pathParams: ['source', 'target'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    assuredworkloads_v1beta1.Resource$Organizations$Locations$Workloads$Organizations$Locations$Workloads = Resource$Organizations$Locations$Workloads$Organizations$Locations$Workloads;
+    class Resource$Organizations$Locations$Workloads$Violations {
+        constructor(context) {
+            this.context = context;
+        }
+        acknowledge(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}:acknowledge').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'POST',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        get(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['name'],
+                pathParams: ['name'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+        list(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+parent}/violations').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['parent'],
+                pathParams: ['parent'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    assuredworkloads_v1beta1.Resource$Organizations$Locations$Workloads$Violations = Resource$Organizations$Locations$Workloads$Violations;
+    class Resource$Projects {
+        constructor(context) {
+            this.context = context;
+            this.organizations = new Resource$Projects$Organizations(this.context);
+        }
+    }
+    assuredworkloads_v1beta1.Resource$Projects = Resource$Projects;
+    class Resource$Projects$Organizations {
+        constructor(context) {
+            this.context = context;
+            this.locations = new Resource$Projects$Organizations$Locations(this.context);
+        }
+    }
+    assuredworkloads_v1beta1.Resource$Projects$Organizations = Resource$Projects$Organizations;
+    class Resource$Projects$Organizations$Locations {
+        constructor(context) {
+            this.context = context;
+            this.workloads = new Resource$Projects$Organizations$Locations$Workloads(this.context);
+        }
+    }
+    assuredworkloads_v1beta1.Resource$Projects$Organizations$Locations = Resource$Projects$Organizations$Locations;
+    class Resource$Projects$Organizations$Locations$Workloads {
+        constructor(context) {
+            this.context = context;
+        }
+        analyzeWorkloadMove(paramsOrCallback, optionsOrCallback, callback) {
+            let params = (paramsOrCallback ||
+                {});
+            let options = (optionsOrCallback || {});
+            if (typeof paramsOrCallback === 'function') {
+                callback = paramsOrCallback;
+                params =
+                    {};
+                options = {};
+            }
+            if (typeof optionsOrCallback === 'function') {
+                callback = optionsOrCallback;
+                options = {};
+            }
+            const rootUrl = options.rootUrl || 'https://assuredworkloads.googleapis.com/';
+            const parameters = {
+                options: Object.assign({
+                    url: (rootUrl + '/v1beta1/{+project}/{+target}:analyzeWorkloadMove').replace(/([^:]\/)\/+/g, '$1'),
+                    method: 'GET',
+                }, options),
+                params,
+                requiredParams: ['project', 'target'],
+                pathParams: ['project', 'target'],
+                context: this.context,
+            };
+            if (callback) {
+                (0, googleapis_common_1.createAPIRequest)(parameters, callback);
+            }
+            else {
+                return (0, googleapis_common_1.createAPIRequest)(parameters);
+            }
+        }
+    }
+    assuredworkloads_v1beta1.Resource$Projects$Organizations$Locations$Workloads = Resource$Projects$Organizations$Locations$Workloads;
+})(assuredworkloads_v1beta1 = exports.assuredworkloads_v1beta1 || (exports.assuredworkloads_v1beta1 = {}));

node_modules/googleapis/build/src/apis/authorizedbuyersmarketplace/index.d.ts

@@ -0,0 +1,12 @@
+/*! THIS FILE IS AUTO-GENERATED */
+import { AuthPlus } from 'googleapis-common';
+import { authorizedbuyersmarketplace_v1 } from './v1';
+export declare const VERSIONS: {
+    v1: typeof authorizedbuyersmarketplace_v1.Authorizedbuyersmarketplace;
+};
+export declare function authorizedbuyersmarketplace(version: 'v1'): authorizedbuyersmarketplace_v1.Authorizedbuyersmarketplace;
+export declare function authorizedbuyersmarketplace(options: authorizedbuyersmarketplace_v1.Options): authorizedbuyersmarketplace_v1.Authorizedbuyersmarketplace;
+declare const auth: AuthPlus;
+export { auth };
+export { authorizedbuyersmarketplace_v1 };
+export { AuthPlus, GlobalOptions, APIRequestContext, GoogleConfigurable, StreamMethodOptions, GaxiosPromise, MethodOptions, BodyResponseCallback, } from 'googleapis-common';