@googleapis/vault 4.0.0 → 6.1.0

package/build/v1.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosPromise, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
+import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosResponseWithHTTP2, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
 import { Readable } from 'stream';
 export declare namespace vault_v1 {
     export interface Options extends GlobalOptions {
@@ -365,6 +365,10 @@ export declare namespace vault_v1 {
          * Set to true to include Team Drive.
          */
         includeTeamDrives?: boolean | null;
+        /**
+         * Optional. Options to include or exclude documents in shared drives. We recommend using this field over include_shared_drives. This field overrides include_shared_drives and include_team_drives when set.
+         */
+        sharedDrivesOption?: string | null;
         /**
          * Search the current version of the Drive file, but export the contents of the last version saved before 12:00 AM UTC on the specified date. Enter the date in UTC.
          */
@@ -1152,154 +1156,771 @@ export declare namespace vault_v1 {
         constructor(context: APIRequestContext);
         /**
          * Adds an account as a matter collaborator.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.matters.addPermissions({
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "ccMe": false,
+         *       //   "matterPermission": {},
+         *       //   "sendEmails": false
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "role": "my_role"
+         *   // }
+         * }
+         *
+         * 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.
          */
-        addPermissions(params: Params$Resource$Matters$Addpermissions, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        addPermissions(params?: Params$Resource$Matters$Addpermissions, options?: MethodOptions): GaxiosPromise<Schema$MatterPermission>;
+        addPermissions(params: Params$Resource$Matters$Addpermissions, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        addPermissions(params?: Params$Resource$Matters$Addpermissions, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$MatterPermission>>;
         addPermissions(params: Params$Resource$Matters$Addpermissions, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         addPermissions(params: Params$Resource$Matters$Addpermissions, options: MethodOptions | BodyResponseCallback<Schema$MatterPermission>, callback: BodyResponseCallback<Schema$MatterPermission>): void;
         addPermissions(params: Params$Resource$Matters$Addpermissions, callback: BodyResponseCallback<Schema$MatterPermission>): void;
         addPermissions(callback: BodyResponseCallback<Schema$MatterPermission>): void;
         /**
          * Closes the specified matter. Returns the matter with updated state.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.matters.close({
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {}
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "matter": {}
+         *   // }
+         * }
+         *
+         * 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.
          */
-        close(params: Params$Resource$Matters$Close, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        close(params?: Params$Resource$Matters$Close, options?: MethodOptions): GaxiosPromise<Schema$CloseMatterResponse>;
+        close(params: Params$Resource$Matters$Close, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        close(params?: Params$Resource$Matters$Close, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$CloseMatterResponse>>;
         close(params: Params$Resource$Matters$Close, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         close(params: Params$Resource$Matters$Close, options: MethodOptions | BodyResponseCallback<Schema$CloseMatterResponse>, callback: BodyResponseCallback<Schema$CloseMatterResponse>): void;
         close(params: Params$Resource$Matters$Close, callback: BodyResponseCallback<Schema$CloseMatterResponse>): void;
         close(callback: BodyResponseCallback<Schema$CloseMatterResponse>): void;
         /**
          * Counts the accounts processed by the specified query.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.matters.count({
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "query": {},
+         *       //   "view": "my_view"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "done": false,
+         *   //   "error": {},
+         *   //   "metadata": {},
+         *   //   "name": "my_name",
+         *   //   "response": {}
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        count(params: Params$Resource$Matters$Count, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        count(params?: Params$Resource$Matters$Count, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        count(params: Params$Resource$Matters$Count, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        count(params?: Params$Resource$Matters$Count, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         count(params: Params$Resource$Matters$Count, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         count(params: Params$Resource$Matters$Count, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         count(params: Params$Resource$Matters$Count, callback: BodyResponseCallback<Schema$Operation>): void;
         count(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Creates a matter with the given name and description. The initial state is open, and the owner is the method caller. Returns the created matter with default view.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.matters.create({
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "description": "my_description",
+         *       //   "matterId": "my_matterId",
+         *       //   "matterPermissions": [],
+         *       //   "matterRegion": "my_matterRegion",
+         *       //   "name": "my_name",
+         *       //   "state": "my_state"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "description": "my_description",
+         *   //   "matterId": "my_matterId",
+         *   //   "matterPermissions": [],
+         *   //   "matterRegion": "my_matterRegion",
+         *   //   "name": "my_name",
+         *   //   "state": "my_state"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        create(params: Params$Resource$Matters$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Matters$Create, options?: MethodOptions): GaxiosPromise<Schema$Matter>;
+        create(params: Params$Resource$Matters$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Matters$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Matter>>;
         create(params: Params$Resource$Matters$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Matters$Create, options: MethodOptions | BodyResponseCallback<Schema$Matter>, callback: BodyResponseCallback<Schema$Matter>): void;
         create(params: Params$Resource$Matters$Create, callback: BodyResponseCallback<Schema$Matter>): void;
         create(callback: BodyResponseCallback<Schema$Matter>): void;
         /**
          * Deletes the specified matter. Returns the matter with updated state.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.matters.delete({
+         *     // The matter ID
+         *     matterId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "description": "my_description",
+         *   //   "matterId": "my_matterId",
+         *   //   "matterPermissions": [],
+         *   //   "matterRegion": "my_matterRegion",
+         *   //   "name": "my_name",
+         *   //   "state": "my_state"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        delete(params: Params$Resource$Matters$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Matters$Delete, options?: MethodOptions): GaxiosPromise<Schema$Matter>;
+        delete(params: Params$Resource$Matters$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Matters$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Matter>>;
         delete(params: Params$Resource$Matters$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Matters$Delete, options: MethodOptions | BodyResponseCallback<Schema$Matter>, callback: BodyResponseCallback<Schema$Matter>): void;
         delete(params: Params$Resource$Matters$Delete, callback: BodyResponseCallback<Schema$Matter>): void;
         delete(callback: BodyResponseCallback<Schema$Matter>): void;
         /**
          * Gets the specified matter.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery',
+         *       'https://www.googleapis.com/auth/ediscovery.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 vault.matters.get({
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *     // Specifies how much information about the matter to return in the response.
+         *     view: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "description": "my_description",
+         *   //   "matterId": "my_matterId",
+         *   //   "matterPermissions": [],
+         *   //   "matterRegion": "my_matterRegion",
+         *   //   "name": "my_name",
+         *   //   "state": "my_state"
+         *   // }
+         * }
+         *
+         * 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$Matters$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Matters$Get, options?: MethodOptions): GaxiosPromise<Schema$Matter>;
+        get(params: Params$Resource$Matters$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Matters$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Matter>>;
         get(params: Params$Resource$Matters$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Matters$Get, options: MethodOptions | BodyResponseCallback<Schema$Matter>, callback: BodyResponseCallback<Schema$Matter>): void;
         get(params: Params$Resource$Matters$Get, callback: BodyResponseCallback<Schema$Matter>): void;
         get(callback: BodyResponseCallback<Schema$Matter>): void;
         /**
          * Lists matters the requestor has access to.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery',
+         *       'https://www.googleapis.com/auth/ediscovery.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 vault.matters.list({
+         *     // The number of matters to return in the response. Default and maximum are 100.
+         *     pageSize: 'placeholder-value',
+         *     // The pagination token as returned in the response.
+         *     pageToken: 'placeholder-value',
+         *     // If set, lists only matters with the specified state. The default lists matters of all states.
+         *     state: 'placeholder-value',
+         *     // Specifies how much information about the matter to return in response.
+         *     view: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "matters": [],
+         *   //   "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$Matters$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Matters$List, options?: MethodOptions): GaxiosPromise<Schema$ListMattersResponse>;
+        list(params: Params$Resource$Matters$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Matters$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListMattersResponse>>;
         list(params: Params$Resource$Matters$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Matters$List, options: MethodOptions | BodyResponseCallback<Schema$ListMattersResponse>, callback: BodyResponseCallback<Schema$ListMattersResponse>): void;
         list(params: Params$Resource$Matters$List, callback: BodyResponseCallback<Schema$ListMattersResponse>): void;
         list(callback: BodyResponseCallback<Schema$ListMattersResponse>): void;
         /**
          * Removes an account as a matter collaborator.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.matters.removePermissions({
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountId": "my_accountId"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {}
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        removePermissions(params: Params$Resource$Matters$Removepermissions, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        removePermissions(params?: Params$Resource$Matters$Removepermissions, options?: MethodOptions): GaxiosPromise<Schema$Empty>;
+        removePermissions(params: Params$Resource$Matters$Removepermissions, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        removePermissions(params?: Params$Resource$Matters$Removepermissions, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Empty>>;
         removePermissions(params: Params$Resource$Matters$Removepermissions, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         removePermissions(params: Params$Resource$Matters$Removepermissions, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;
         removePermissions(params: Params$Resource$Matters$Removepermissions, callback: BodyResponseCallback<Schema$Empty>): void;
         removePermissions(callback: BodyResponseCallback<Schema$Empty>): void;
         /**
          * Reopens the specified matter. Returns the matter with updated state.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.matters.reopen({
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {}
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "matter": {}
+         *   // }
+         * }
+         *
+         * 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.
          */
-        reopen(params: Params$Resource$Matters$Reopen, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        reopen(params?: Params$Resource$Matters$Reopen, options?: MethodOptions): GaxiosPromise<Schema$ReopenMatterResponse>;
+        reopen(params: Params$Resource$Matters$Reopen, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        reopen(params?: Params$Resource$Matters$Reopen, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ReopenMatterResponse>>;
         reopen(params: Params$Resource$Matters$Reopen, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         reopen(params: Params$Resource$Matters$Reopen, options: MethodOptions | BodyResponseCallback<Schema$ReopenMatterResponse>, callback: BodyResponseCallback<Schema$ReopenMatterResponse>): void;
         reopen(params: Params$Resource$Matters$Reopen, callback: BodyResponseCallback<Schema$ReopenMatterResponse>): void;
         reopen(callback: BodyResponseCallback<Schema$ReopenMatterResponse>): void;
         /**
          * Undeletes the specified matter. Returns the matter with updated state.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.matters.undelete({
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {}
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "description": "my_description",
+         *   //   "matterId": "my_matterId",
+         *   //   "matterPermissions": [],
+         *   //   "matterRegion": "my_matterRegion",
+         *   //   "name": "my_name",
+         *   //   "state": "my_state"
+         *   // }
+         * }
+         *
+         * 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.
          */
-        undelete(params: Params$Resource$Matters$Undelete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        undelete(params?: Params$Resource$Matters$Undelete, options?: MethodOptions): GaxiosPromise<Schema$Matter>;
+        undelete(params: Params$Resource$Matters$Undelete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        undelete(params?: Params$Resource$Matters$Undelete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Matter>>;
         undelete(params: Params$Resource$Matters$Undelete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         undelete(params: Params$Resource$Matters$Undelete, options: MethodOptions | BodyResponseCallback<Schema$Matter>, callback: BodyResponseCallback<Schema$Matter>): void;
         undelete(params: Params$Resource$Matters$Undelete, callback: BodyResponseCallback<Schema$Matter>): void;
         undelete(callback: BodyResponseCallback<Schema$Matter>): void;
         /**
          * Updates the specified matter. This updates only the name and description of the matter, identified by matter ID. Changes to any other fields are ignored. Returns the default view of the matter.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.matters.update({
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "description": "my_description",
+         *       //   "matterId": "my_matterId",
+         *       //   "matterPermissions": [],
+         *       //   "matterRegion": "my_matterRegion",
+         *       //   "name": "my_name",
+         *       //   "state": "my_state"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "description": "my_description",
+         *   //   "matterId": "my_matterId",
+         *   //   "matterPermissions": [],
+         *   //   "matterRegion": "my_matterRegion",
+         *   //   "name": "my_name",
+         *   //   "state": "my_state"
+         *   // }
+         * }
+         *
+         * 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$Matters$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        update(params?: Params$Resource$Matters$Update, options?: MethodOptions): GaxiosPromise<Schema$Matter>;
+        update(params: Params$Resource$Matters$Update, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        update(params?: Params$Resource$Matters$Update, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Matter>>;
         update(params: Params$Resource$Matters$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         update(params: Params$Resource$Matters$Update, options: MethodOptions | BodyResponseCallback<Schema$Matter>, callback: BodyResponseCallback<Schema$Matter>): void;
         update(params: Params$Resource$Matters$Update, callback: BodyResponseCallback<Schema$Matter>): void;
@@ -1420,56 +2041,291 @@ export declare namespace vault_v1 {
         constructor(context: APIRequestContext);
         /**
          * Creates an export.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.matters.exports.create({
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "cloudStorageSink": {},
+         *       //   "createTime": "my_createTime",
+         *       //   "exportOptions": {},
+         *       //   "id": "my_id",
+         *       //   "matterId": "my_matterId",
+         *       //   "name": "my_name",
+         *       //   "parentExportId": "my_parentExportId",
+         *       //   "query": {},
+         *       //   "requester": {},
+         *       //   "stats": {},
+         *       //   "status": "my_status"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "cloudStorageSink": {},
+         *   //   "createTime": "my_createTime",
+         *   //   "exportOptions": {},
+         *   //   "id": "my_id",
+         *   //   "matterId": "my_matterId",
+         *   //   "name": "my_name",
+         *   //   "parentExportId": "my_parentExportId",
+         *   //   "query": {},
+         *   //   "requester": {},
+         *   //   "stats": {},
+         *   //   "status": "my_status"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        create(params: Params$Resource$Matters$Exports$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Matters$Exports$Create, options?: MethodOptions): GaxiosPromise<Schema$Export>;
+        create(params: Params$Resource$Matters$Exports$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Matters$Exports$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Export>>;
         create(params: Params$Resource$Matters$Exports$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Matters$Exports$Create, options: MethodOptions | BodyResponseCallback<Schema$Export>, callback: BodyResponseCallback<Schema$Export>): void;
         create(params: Params$Resource$Matters$Exports$Create, callback: BodyResponseCallback<Schema$Export>): void;
         create(callback: BodyResponseCallback<Schema$Export>): void;
         /**
          * Deletes an export.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.matters.exports.delete({
+         *     // The export ID.
+         *     exportId: 'placeholder-value',
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {}
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        delete(params: Params$Resource$Matters$Exports$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Matters$Exports$Delete, options?: MethodOptions): GaxiosPromise<Schema$Empty>;
+        delete(params: Params$Resource$Matters$Exports$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Matters$Exports$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Empty>>;
         delete(params: Params$Resource$Matters$Exports$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Matters$Exports$Delete, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;
         delete(params: Params$Resource$Matters$Exports$Delete, callback: BodyResponseCallback<Schema$Empty>): void;
         delete(callback: BodyResponseCallback<Schema$Empty>): void;
         /**
          * Gets an export.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery',
+         *       'https://www.googleapis.com/auth/ediscovery.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 vault.matters.exports.get({
+         *     // The export ID.
+         *     exportId: 'placeholder-value',
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "cloudStorageSink": {},
+         *   //   "createTime": "my_createTime",
+         *   //   "exportOptions": {},
+         *   //   "id": "my_id",
+         *   //   "matterId": "my_matterId",
+         *   //   "name": "my_name",
+         *   //   "parentExportId": "my_parentExportId",
+         *   //   "query": {},
+         *   //   "requester": {},
+         *   //   "stats": {},
+         *   //   "status": "my_status"
+         *   // }
+         * }
+         *
+         * 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$Matters$Exports$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Matters$Exports$Get, options?: MethodOptions): GaxiosPromise<Schema$Export>;
+        get(params: Params$Resource$Matters$Exports$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Matters$Exports$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Export>>;
         get(params: Params$Resource$Matters$Exports$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Matters$Exports$Get, options: MethodOptions | BodyResponseCallback<Schema$Export>, callback: BodyResponseCallback<Schema$Export>): void;
         get(params: Params$Resource$Matters$Exports$Get, callback: BodyResponseCallback<Schema$Export>): void;
         get(callback: BodyResponseCallback<Schema$Export>): void;
         /**
          * Lists details about the exports in the specified matter.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery',
+         *       'https://www.googleapis.com/auth/ediscovery.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 vault.matters.exports.list({
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *     // The number of exports to return in the response.
+         *     pageSize: 'placeholder-value',
+         *     // The pagination token as returned in the response.
+         *     pageToken: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "exports": [],
+         *   //   "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$Matters$Exports$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Matters$Exports$List, options?: MethodOptions): GaxiosPromise<Schema$ListExportsResponse>;
+        list(params: Params$Resource$Matters$Exports$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Matters$Exports$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListExportsResponse>>;
         list(params: Params$Resource$Matters$Exports$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Matters$Exports$List, options: MethodOptions | BodyResponseCallback<Schema$ListExportsResponse>, callback: BodyResponseCallback<Schema$ListExportsResponse>): void;
         list(params: Params$Resource$Matters$Exports$List, callback: BodyResponseCallback<Schema$ListExportsResponse>): void;
@@ -1525,98 +2381,506 @@ export declare namespace vault_v1 {
         constructor(context: APIRequestContext);
         /**
          * Adds accounts to a hold. Returns a list of accounts that have been successfully added. Accounts can be added only to an existing account-based hold.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.matters.holds.addHeldAccounts({
+         *     // The hold ID.
+         *     holdId: 'placeholder-value',
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountIds": [],
+         *       //   "emails": []
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "responses": []
+         *   // }
+         * }
+         *
+         * 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.
          */
-        addHeldAccounts(params: Params$Resource$Matters$Holds$Addheldaccounts, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        addHeldAccounts(params?: Params$Resource$Matters$Holds$Addheldaccounts, options?: MethodOptions): GaxiosPromise<Schema$AddHeldAccountsResponse>;
+        addHeldAccounts(params: Params$Resource$Matters$Holds$Addheldaccounts, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        addHeldAccounts(params?: Params$Resource$Matters$Holds$Addheldaccounts, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$AddHeldAccountsResponse>>;
         addHeldAccounts(params: Params$Resource$Matters$Holds$Addheldaccounts, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         addHeldAccounts(params: Params$Resource$Matters$Holds$Addheldaccounts, options: MethodOptions | BodyResponseCallback<Schema$AddHeldAccountsResponse>, callback: BodyResponseCallback<Schema$AddHeldAccountsResponse>): void;
         addHeldAccounts(params: Params$Resource$Matters$Holds$Addheldaccounts, callback: BodyResponseCallback<Schema$AddHeldAccountsResponse>): void;
         addHeldAccounts(callback: BodyResponseCallback<Schema$AddHeldAccountsResponse>): void;
         /**
          * Creates a hold in the specified matter.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.matters.holds.create({
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accounts": [],
+         *       //   "corpus": "my_corpus",
+         *       //   "holdId": "my_holdId",
+         *       //   "name": "my_name",
+         *       //   "orgUnit": {},
+         *       //   "query": {},
+         *       //   "updateTime": "my_updateTime"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accounts": [],
+         *   //   "corpus": "my_corpus",
+         *   //   "holdId": "my_holdId",
+         *   //   "name": "my_name",
+         *   //   "orgUnit": {},
+         *   //   "query": {},
+         *   //   "updateTime": "my_updateTime"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        create(params: Params$Resource$Matters$Holds$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Matters$Holds$Create, options?: MethodOptions): GaxiosPromise<Schema$Hold>;
+        create(params: Params$Resource$Matters$Holds$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Matters$Holds$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Hold>>;
         create(params: Params$Resource$Matters$Holds$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Matters$Holds$Create, options: MethodOptions | BodyResponseCallback<Schema$Hold>, callback: BodyResponseCallback<Schema$Hold>): void;
         create(params: Params$Resource$Matters$Holds$Create, callback: BodyResponseCallback<Schema$Hold>): void;
         create(callback: BodyResponseCallback<Schema$Hold>): void;
         /**
          * Removes the specified hold and releases the accounts or organizational unit covered by the hold. If the data is not preserved by another hold or retention rule, it might be purged.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.matters.holds.delete({
+         *     // The hold ID.
+         *     holdId: 'placeholder-value',
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {}
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        delete(params: Params$Resource$Matters$Holds$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Matters$Holds$Delete, options?: MethodOptions): GaxiosPromise<Schema$Empty>;
+        delete(params: Params$Resource$Matters$Holds$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Matters$Holds$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Empty>>;
         delete(params: Params$Resource$Matters$Holds$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Matters$Holds$Delete, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;
         delete(params: Params$Resource$Matters$Holds$Delete, callback: BodyResponseCallback<Schema$Empty>): void;
         delete(callback: BodyResponseCallback<Schema$Empty>): void;
         /**
          * Gets the specified hold.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery',
+         *       'https://www.googleapis.com/auth/ediscovery.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 vault.matters.holds.get({
+         *     // The hold ID.
+         *     holdId: 'placeholder-value',
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *     // The amount of detail to return for a hold.
+         *     view: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accounts": [],
+         *   //   "corpus": "my_corpus",
+         *   //   "holdId": "my_holdId",
+         *   //   "name": "my_name",
+         *   //   "orgUnit": {},
+         *   //   "query": {},
+         *   //   "updateTime": "my_updateTime"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        get(params: Params$Resource$Matters$Holds$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Matters$Holds$Get, options?: MethodOptions): GaxiosPromise<Schema$Hold>;
+        get(params: Params$Resource$Matters$Holds$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Matters$Holds$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Hold>>;
         get(params: Params$Resource$Matters$Holds$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Matters$Holds$Get, options: MethodOptions | BodyResponseCallback<Schema$Hold>, callback: BodyResponseCallback<Schema$Hold>): void;
         get(params: Params$Resource$Matters$Holds$Get, callback: BodyResponseCallback<Schema$Hold>): void;
         get(callback: BodyResponseCallback<Schema$Hold>): void;
         /**
          * Lists the holds in a matter.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery',
+         *       'https://www.googleapis.com/auth/ediscovery.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 vault.matters.holds.list({
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *     // The number of holds to return in the response, between 0 and 100 inclusive. Leaving this empty, or as 0, is the same as **page_size** = 100.
+         *     pageSize: 'placeholder-value',
+         *     // The pagination token as returned in the response. An empty token means start from the beginning.
+         *     pageToken: 'placeholder-value',
+         *     // The amount of detail to return for a hold.
+         *     view: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "holds": [],
+         *   //   "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$Matters$Holds$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Matters$Holds$List, options?: MethodOptions): GaxiosPromise<Schema$ListHoldsResponse>;
+        list(params: Params$Resource$Matters$Holds$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Matters$Holds$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListHoldsResponse>>;
         list(params: Params$Resource$Matters$Holds$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Matters$Holds$List, options: MethodOptions | BodyResponseCallback<Schema$ListHoldsResponse>, callback: BodyResponseCallback<Schema$ListHoldsResponse>): void;
         list(params: Params$Resource$Matters$Holds$List, callback: BodyResponseCallback<Schema$ListHoldsResponse>): void;
         list(callback: BodyResponseCallback<Schema$ListHoldsResponse>): void;
         /**
          * Removes the specified accounts from a hold. Returns a list of statuses in the same order as the request.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.matters.holds.removeHeldAccounts({
+         *     // The hold ID.
+         *     holdId: 'placeholder-value',
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountIds": []
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "statuses": []
+         *   // }
+         * }
+         *
+         * 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.
          */
-        removeHeldAccounts(params: Params$Resource$Matters$Holds$Removeheldaccounts, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        removeHeldAccounts(params?: Params$Resource$Matters$Holds$Removeheldaccounts, options?: MethodOptions): GaxiosPromise<Schema$RemoveHeldAccountsResponse>;
+        removeHeldAccounts(params: Params$Resource$Matters$Holds$Removeheldaccounts, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        removeHeldAccounts(params?: Params$Resource$Matters$Holds$Removeheldaccounts, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$RemoveHeldAccountsResponse>>;
         removeHeldAccounts(params: Params$Resource$Matters$Holds$Removeheldaccounts, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         removeHeldAccounts(params: Params$Resource$Matters$Holds$Removeheldaccounts, options: MethodOptions | BodyResponseCallback<Schema$RemoveHeldAccountsResponse>, callback: BodyResponseCallback<Schema$RemoveHeldAccountsResponse>): void;
         removeHeldAccounts(params: Params$Resource$Matters$Holds$Removeheldaccounts, callback: BodyResponseCallback<Schema$RemoveHeldAccountsResponse>): void;
         removeHeldAccounts(callback: BodyResponseCallback<Schema$RemoveHeldAccountsResponse>): void;
         /**
          * Updates the scope (organizational unit or accounts) and query parameters of a hold. You cannot add accounts to a hold that covers an organizational unit, nor can you add organizational units to a hold that covers individual accounts. If you try, the unsupported values are ignored.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.matters.holds.update({
+         *     // The ID of the hold.
+         *     holdId: 'placeholder-value',
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accounts": [],
+         *       //   "corpus": "my_corpus",
+         *       //   "holdId": "my_holdId",
+         *       //   "name": "my_name",
+         *       //   "orgUnit": {},
+         *       //   "query": {},
+         *       //   "updateTime": "my_updateTime"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accounts": [],
+         *   //   "corpus": "my_corpus",
+         *   //   "holdId": "my_holdId",
+         *   //   "name": "my_name",
+         *   //   "orgUnit": {},
+         *   //   "query": {},
+         *   //   "updateTime": "my_updateTime"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        update(params: Params$Resource$Matters$Holds$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        update(params?: Params$Resource$Matters$Holds$Update, options?: MethodOptions): GaxiosPromise<Schema$Hold>;
+        update(params: Params$Resource$Matters$Holds$Update, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        update(params?: Params$Resource$Matters$Holds$Update, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Hold>>;
         update(params: Params$Resource$Matters$Holds$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         update(params: Params$Resource$Matters$Holds$Update, options: MethodOptions | BodyResponseCallback<Schema$Hold>, callback: BodyResponseCallback<Schema$Hold>): void;
         update(params: Params$Resource$Matters$Holds$Update, callback: BodyResponseCallback<Schema$Hold>): void;
@@ -1721,42 +2985,205 @@ export declare namespace vault_v1 {
         constructor(context: APIRequestContext);
         /**
          * Adds an account to a hold. Accounts can be added only to a hold that does not have an organizational unit set. If you try to add an account to an organizational unit-based hold, an error is returned.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.matters.holds.accounts.create({
+         *     // The hold ID.
+         *     holdId: 'placeholder-value',
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountId": "my_accountId",
+         *       //   "email": "my_email",
+         *       //   "firstName": "my_firstName",
+         *       //   "holdTime": "my_holdTime",
+         *       //   "lastName": "my_lastName"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "email": "my_email",
+         *   //   "firstName": "my_firstName",
+         *   //   "holdTime": "my_holdTime",
+         *   //   "lastName": "my_lastName"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        create(params: Params$Resource$Matters$Holds$Accounts$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Matters$Holds$Accounts$Create, options?: MethodOptions): GaxiosPromise<Schema$HeldAccount>;
+        create(params: Params$Resource$Matters$Holds$Accounts$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Matters$Holds$Accounts$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$HeldAccount>>;
         create(params: Params$Resource$Matters$Holds$Accounts$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Matters$Holds$Accounts$Create, options: MethodOptions | BodyResponseCallback<Schema$HeldAccount>, callback: BodyResponseCallback<Schema$HeldAccount>): void;
         create(params: Params$Resource$Matters$Holds$Accounts$Create, callback: BodyResponseCallback<Schema$HeldAccount>): void;
         create(callback: BodyResponseCallback<Schema$HeldAccount>): void;
         /**
          * Removes an account from a hold.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.matters.holds.accounts.delete({
+         *     // The ID of the account to remove from the hold.
+         *     accountId: 'placeholder-value',
+         *     // The hold ID.
+         *     holdId: 'placeholder-value',
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {}
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        delete(params: Params$Resource$Matters$Holds$Accounts$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Matters$Holds$Accounts$Delete, options?: MethodOptions): GaxiosPromise<Schema$Empty>;
+        delete(params: Params$Resource$Matters$Holds$Accounts$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Matters$Holds$Accounts$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Empty>>;
         delete(params: Params$Resource$Matters$Holds$Accounts$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Matters$Holds$Accounts$Delete, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;
         delete(params: Params$Resource$Matters$Holds$Accounts$Delete, callback: BodyResponseCallback<Schema$Empty>): void;
         delete(callback: BodyResponseCallback<Schema$Empty>): void;
         /**
          * Lists the accounts covered by a hold. This can list only individually-specified accounts covered by the hold. If the hold covers an organizational unit, use the [Admin SDK](https://developers.google.com/admin-sdk/). to list the members of the organizational unit on hold.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery',
+         *       'https://www.googleapis.com/auth/ediscovery.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 vault.matters.holds.accounts.list({
+         *     // The hold ID.
+         *     holdId: 'placeholder-value',
+         *     // The matter ID.
+         *     matterId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accounts": []
+         *   // }
+         * }
+         *
+         * 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$Matters$Holds$Accounts$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Matters$Holds$Accounts$List, options?: MethodOptions): GaxiosPromise<Schema$ListHeldAccountsResponse>;
+        list(params: Params$Resource$Matters$Holds$Accounts$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Matters$Holds$Accounts$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListHeldAccountsResponse>>;
         list(params: Params$Resource$Matters$Holds$Accounts$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Matters$Holds$Accounts$List, options: MethodOptions | BodyResponseCallback<Schema$ListHeldAccountsResponse>, callback: BodyResponseCallback<Schema$ListHeldAccountsResponse>): void;
         list(params: Params$Resource$Matters$Holds$Accounts$List, callback: BodyResponseCallback<Schema$ListHeldAccountsResponse>): void;
@@ -1805,56 +3232,273 @@ export declare namespace vault_v1 {
         constructor(context: APIRequestContext);
         /**
          * Creates a saved query.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.matters.savedQueries.create({
+         *     // The ID of the matter to create the saved query in.
+         *     matterId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "createTime": "my_createTime",
+         *       //   "displayName": "my_displayName",
+         *       //   "matterId": "my_matterId",
+         *       //   "query": {},
+         *       //   "savedQueryId": "my_savedQueryId"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "createTime": "my_createTime",
+         *   //   "displayName": "my_displayName",
+         *   //   "matterId": "my_matterId",
+         *   //   "query": {},
+         *   //   "savedQueryId": "my_savedQueryId"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        create(params: Params$Resource$Matters$Savedqueries$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Matters$Savedqueries$Create, options?: MethodOptions): GaxiosPromise<Schema$SavedQuery>;
+        create(params: Params$Resource$Matters$Savedqueries$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Matters$Savedqueries$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$SavedQuery>>;
         create(params: Params$Resource$Matters$Savedqueries$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Matters$Savedqueries$Create, options: MethodOptions | BodyResponseCallback<Schema$SavedQuery>, callback: BodyResponseCallback<Schema$SavedQuery>): void;
         create(params: Params$Resource$Matters$Savedqueries$Create, callback: BodyResponseCallback<Schema$SavedQuery>): void;
         create(callback: BodyResponseCallback<Schema$SavedQuery>): void;
         /**
          * Deletes the specified saved query.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.matters.savedQueries.delete({
+         *     // The ID of the matter to delete the saved query from.
+         *     matterId: 'placeholder-value',
+         *     // ID of the saved query to delete.
+         *     savedQueryId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {}
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        delete(params: Params$Resource$Matters$Savedqueries$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Matters$Savedqueries$Delete, options?: MethodOptions): GaxiosPromise<Schema$Empty>;
+        delete(params: Params$Resource$Matters$Savedqueries$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Matters$Savedqueries$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Empty>>;
         delete(params: Params$Resource$Matters$Savedqueries$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Matters$Savedqueries$Delete, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;
         delete(params: Params$Resource$Matters$Savedqueries$Delete, callback: BodyResponseCallback<Schema$Empty>): void;
         delete(callback: BodyResponseCallback<Schema$Empty>): void;
         /**
          * Retrieves the specified saved query.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery',
+         *       'https://www.googleapis.com/auth/ediscovery.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 vault.matters.savedQueries.get({
+         *     // The ID of the matter to get the saved query from.
+         *     matterId: 'placeholder-value',
+         *     // ID of the saved query to retrieve.
+         *     savedQueryId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "createTime": "my_createTime",
+         *   //   "displayName": "my_displayName",
+         *   //   "matterId": "my_matterId",
+         *   //   "query": {},
+         *   //   "savedQueryId": "my_savedQueryId"
+         *   // }
+         * }
+         *
+         * 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$Matters$Savedqueries$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Matters$Savedqueries$Get, options?: MethodOptions): GaxiosPromise<Schema$SavedQuery>;
+        get(params: Params$Resource$Matters$Savedqueries$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Matters$Savedqueries$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$SavedQuery>>;
         get(params: Params$Resource$Matters$Savedqueries$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Matters$Savedqueries$Get, options: MethodOptions | BodyResponseCallback<Schema$SavedQuery>, callback: BodyResponseCallback<Schema$SavedQuery>): void;
         get(params: Params$Resource$Matters$Savedqueries$Get, callback: BodyResponseCallback<Schema$SavedQuery>): void;
         get(callback: BodyResponseCallback<Schema$SavedQuery>): void;
         /**
          * Lists the saved queries in a matter.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery',
+         *       'https://www.googleapis.com/auth/ediscovery.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 vault.matters.savedQueries.list({
+         *     // The ID of the matter to get the saved queries for.
+         *     matterId: 'placeholder-value',
+         *     // The maximum number of saved queries to return.
+         *     pageSize: 'placeholder-value',
+         *     // The pagination token as returned in the previous response. An empty token means start from the beginning.
+         *     pageToken: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "nextPageToken": "my_nextPageToken",
+         *   //   "savedQueries": []
+         *   // }
+         * }
+         *
+         * 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$Matters$Savedqueries$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Matters$Savedqueries$List, options?: MethodOptions): GaxiosPromise<Schema$ListSavedQueriesResponse>;
+        list(params: Params$Resource$Matters$Savedqueries$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Matters$Savedqueries$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListSavedQueriesResponse>>;
         list(params: Params$Resource$Matters$Savedqueries$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Matters$Savedqueries$List, options: MethodOptions | BodyResponseCallback<Schema$ListSavedQueriesResponse>, callback: BodyResponseCallback<Schema$ListSavedQueriesResponse>): void;
         list(params: Params$Resource$Matters$Savedqueries$List, callback: BodyResponseCallback<Schema$ListSavedQueriesResponse>): void;
@@ -1909,56 +3553,259 @@ export declare namespace vault_v1 {
         constructor(context: APIRequestContext);
         /**
          * Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of `1`, corresponding to `Code.CANCELLED`.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.operations.cancel({
+         *     // The name of the operation resource to be cancelled.
+         *     name: 'operations/.*',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {}
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {}
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        cancel(params: Params$Resource$Operations$Cancel, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        cancel(params?: Params$Resource$Operations$Cancel, options?: MethodOptions): GaxiosPromise<Schema$Empty>;
+        cancel(params: Params$Resource$Operations$Cancel, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        cancel(params?: Params$Resource$Operations$Cancel, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Empty>>;
         cancel(params: Params$Resource$Operations$Cancel, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         cancel(params: Params$Resource$Operations$Cancel, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;
         cancel(params: Params$Resource$Operations$Cancel, callback: BodyResponseCallback<Schema$Empty>): void;
         cancel(callback: BodyResponseCallback<Schema$Empty>): void;
         /**
          * Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery'],
+         *   });
+         *
+         *   // 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 vault.operations.delete({
+         *     // The name of the operation resource to be deleted.
+         *     name: 'operations/.*',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {}
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        delete(params: Params$Resource$Operations$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Operations$Delete, options?: MethodOptions): GaxiosPromise<Schema$Empty>;
+        delete(params: Params$Resource$Operations$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Operations$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Empty>>;
         delete(params: Params$Resource$Operations$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Operations$Delete, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;
         delete(params: Params$Resource$Operations$Delete, callback: BodyResponseCallback<Schema$Empty>): void;
         delete(callback: BodyResponseCallback<Schema$Empty>): void;
         /**
          * Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery',
+         *       'https://www.googleapis.com/auth/ediscovery.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 vault.operations.get({
+         *     // The name of the operation resource.
+         *     name: 'operations/.*',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "done": false,
+         *   //   "error": {},
+         *   //   "metadata": {},
+         *   //   "name": "my_name",
+         *   //   "response": {}
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        get(params: Params$Resource$Operations$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Operations$Get, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        get(params: Params$Resource$Operations$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Operations$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         get(params: Params$Resource$Operations$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Operations$Get, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         get(params: Params$Resource$Operations$Get, callback: BodyResponseCallback<Schema$Operation>): void;
         get(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns `UNIMPLEMENTED`.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/vault.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const vault = google.vault('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/ediscovery',
+         *       'https://www.googleapis.com/auth/ediscovery.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 vault.operations.list({
+         *     // The standard list filter.
+         *     filter: 'placeholder-value',
+         *     // The name of the operation's parent resource.
+         *     name: 'operations',
+         *     // The standard list page size.
+         *     pageSize: 'placeholder-value',
+         *     // The standard list page token.
+         *     pageToken: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "nextPageToken": "my_nextPageToken",
+         *   //   "operations": []
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        list(params: Params$Resource$Operations$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Operations$List, options?: MethodOptions): GaxiosPromise<Schema$ListOperationsResponse>;
+        list(params: Params$Resource$Operations$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Operations$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListOperationsResponse>>;
         list(params: Params$Resource$Operations$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Operations$List, options: MethodOptions | BodyResponseCallback<Schema$ListOperationsResponse>, callback: BodyResponseCallback<Schema$ListOperationsResponse>): void;
         list(params: Params$Resource$Operations$List, callback: BodyResponseCallback<Schema$ListOperationsResponse>): void;