@googleapis/storage 21.3.0 → 22.1.0

package/build/v1.d.ts

@@ -67,6 +67,7 @@ export declare namespace storage_v1 {
         objects: Resource$Objects;
         operations: Resource$Operations;
         projects: Resource$Projects;
+        rapidCaches: Resource$Rapidcaches;
         constructor(options: GlobalOptions, google?: GoogleConfigurable);
     }
     /**
@@ -303,6 +304,8 @@ export declare namespace storage_v1 {
                     matchesSuffix?: string[];
                     noncurrentTimeBefore?: string;
                     numNewerVersions?: number;
+                    sizeAboveBytes?: string;
+                    sizeBelowBytes?: string;
                 };
             }>;
         } | null;
@@ -905,6 +908,10 @@ export declare namespace storage_v1 {
          * The name of the managed folder. Required if not specified by URL parameter.
          */
         name?: string | null;
+        /**
+         * The rapid cache configuration for the managed folder.
+         */
+        rapidCacheConfig?: Schema$RapidCacheConfig;
         /**
          * The link to this managed folder.
          */
@@ -1310,6 +1317,108 @@ export declare namespace storage_v1 {
          */
         version?: number | null;
     }
+    /**
+     * A Rapid Cache instance.
+     */
+    export interface Schema$RapidCache {
+        /**
+         * The cache-level entry admission policy.
+         */
+        admissionPolicy?: string | null;
+        /**
+         * The name of the bucket containing this cache instance.
+         */
+        bucket?: string | null;
+        /**
+         * The type of Rapid Cache this represents. Valid values include: "rapid-cache" and "rapid-cache-ultra".
+         */
+        cacheType?: string | null;
+        /**
+         * The creation time of the cache instance in RFC 3339 format.
+         */
+        createTime?: string | null;
+        /**
+         * The ID of the resource, including the project number, bucket name and rapid cache ID.
+         */
+        id?: string | null;
+        /**
+         * Specifies whether objects are ingested into the cache upon write.
+         */
+        ingestOnWrite?: boolean | null;
+        /**
+         * The kind of item this is. For Rapid Cache, this is always storage#rapidCache.
+         */
+        kind?: string | null;
+        /**
+         * True if the cache instance has an active Update long-running operation.
+         */
+        pendingUpdate?: boolean | null;
+        /**
+         * The ID of the Rapid cache instance.
+         */
+        rapidCacheId?: string | null;
+        /**
+         * The link to this cache instance.
+         */
+        selfLink?: string | null;
+        /**
+         * The current state of the cache instance.
+         */
+        state?: string | null;
+        /**
+         * The TTL of all cache entries in whole seconds. e.g., "7200s".
+         */
+        ttl?: string | null;
+        /**
+         * The modification time of the cache instance metadata in RFC 3339 format.
+         */
+        updateTime?: string | null;
+        /**
+         * The zone in which the cache instance is running. For example, us-central1-a.
+         */
+        zone?: string | null;
+    }
+    /**
+     * Configuration options for the rapid cache of a managed folder.
+     */
+    export interface Schema$RapidCacheConfig {
+        /**
+         * A map of rapid cache IDs to the corresponding `RapidCachePolicy` configurations for a managed folder.
+         */
+        policies?: {
+            [key: string]: Schema$RapidCachePolicy;
+        } | null;
+    }
+    /**
+     * The rapid cache policy configuration for a managed folder.
+     */
+    export interface Schema$RapidCachePolicy {
+        /**
+         * The ingest-on-write policy for objects in the managed folder. When set to `enabled`, objects are automatically ingested into the cache when they are written to the managed folder.
+         */
+        ingestOnWrite?: string | null;
+        /**
+         * The unique identifier of the rapid cache.
+         */
+        rapidCacheId?: string | null;
+    }
+    /**
+     * A list of Rapid Caches.
+     */
+    export interface Schema$RapidCaches {
+        /**
+         * The list of items.
+         */
+        items?: Schema$RapidCache[];
+        /**
+         * The kind of item this is. For lists of Rapid Caches, this is always storage#rapidCaches.
+         */
+        kind?: string | null;
+        /**
+         * The continuation token, used to page through large result sets. Provide this value in a subsequent request to return the next page of results.
+         */
+        nextPageToken?: string | null;
+    }
     /**
      * A Relocate Bucket request.
      */
@@ -5648,6 +5757,7 @@ export declare namespace storage_v1 {
          *   //   "kind": "my_kind",
          *   //   "metageneration": "my_metageneration",
          *   //   "name": "my_name",
+         *   //   "rapidCacheConfig": {},
          *   //   "selfLink": "my_selfLink",
          *   //   "updateTime": "my_updateTime"
          *   // }
@@ -5795,6 +5905,7 @@ export declare namespace storage_v1 {
          *       //   "kind": "my_kind",
          *       //   "metageneration": "my_metageneration",
          *       //   "name": "my_name",
+         *       //   "rapidCacheConfig": {},
          *       //   "selfLink": "my_selfLink",
          *       //   "updateTime": "my_updateTime"
          *       // }
@@ -5810,6 +5921,7 @@ export declare namespace storage_v1 {
          *   //   "kind": "my_kind",
          *   //   "metageneration": "my_metageneration",
          *   //   "name": "my_name",
+         *   //   "rapidCacheConfig": {},
          *   //   "selfLink": "my_selfLink",
          *   //   "updateTime": "my_updateTime"
          *   // }
@@ -6063,6 +6175,100 @@ export declare namespace storage_v1 {
         testIamPermissions(params: Params$Resource$Managedfolders$Testiampermissions, options: MethodOptions | BodyResponseCallback<Schema$TestIamPermissionsResponse>, callback: BodyResponseCallback<Schema$TestIamPermissionsResponse>): void;
         testIamPermissions(params: Params$Resource$Managedfolders$Testiampermissions, callback: BodyResponseCallback<Schema$TestIamPermissionsResponse>): void;
         testIamPermissions(callback: BodyResponseCallback<Schema$TestIamPermissionsResponse>): void;
+        /**
+         * Updates a managed folder using patch semantics.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storage.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 storage = google.storage('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/devstorage.full_control',
+         *       'https://www.googleapis.com/auth/devstorage.read_write',
+         *     ],
+         *   });
+         *
+         *   // 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 storage.managedFolders.update({
+         *     // The name of the bucket containing the managed folder.
+         *     bucket: 'placeholder-value',
+         *     // Makes the operation conditional on whether the metageneration of the managed folder matches the specified value.
+         *     ifMetagenerationMatch: 'placeholder-value',
+         *     // Makes the operation conditional on whether the metageneration of the managed folder doesn't match the specified value.
+         *     ifMetagenerationNotMatch: 'placeholder-value',
+         *     // The name of the managed folder.
+         *     managedFolder: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "bucket": "my_bucket",
+         *       //   "createTime": "my_createTime",
+         *       //   "id": "my_id",
+         *       //   "kind": "my_kind",
+         *       //   "metageneration": "my_metageneration",
+         *       //   "name": "my_name",
+         *       //   "rapidCacheConfig": {},
+         *       //   "selfLink": "my_selfLink",
+         *       //   "updateTime": "my_updateTime"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "bucket": "my_bucket",
+         *   //   "createTime": "my_createTime",
+         *   //   "id": "my_id",
+         *   //   "kind": "my_kind",
+         *   //   "metageneration": "my_metageneration",
+         *   //   "name": "my_name",
+         *   //   "rapidCacheConfig": {},
+         *   //   "selfLink": "my_selfLink",
+         *   //   "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$Managedfolders$Update, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        update(params?: Params$Resource$Managedfolders$Update, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ManagedFolder>>;
+        update(params: Params$Resource$Managedfolders$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        update(params: Params$Resource$Managedfolders$Update, options: MethodOptions | BodyResponseCallback<Schema$ManagedFolder>, callback: BodyResponseCallback<Schema$ManagedFolder>): void;
+        update(params: Params$Resource$Managedfolders$Update, callback: BodyResponseCallback<Schema$ManagedFolder>): void;
+        update(callback: BodyResponseCallback<Schema$ManagedFolder>): void;
     }
     export interface Params$Resource$Managedfolders$Delete extends StandardParameters {
         /**
@@ -6186,6 +6392,28 @@ export declare namespace storage_v1 {
          */
         userProject?: string;
     }
+    export interface Params$Resource$Managedfolders$Update extends StandardParameters {
+        /**
+         * The name of the bucket containing the managed folder.
+         */
+        bucket?: string;
+        /**
+         * Makes the operation conditional on whether the metageneration of the managed folder matches the specified value.
+         */
+        ifMetagenerationMatch?: string;
+        /**
+         * Makes the operation conditional on whether the metageneration of the managed folder doesn't match the specified value.
+         */
+        ifMetagenerationNotMatch?: string;
+        /**
+         * The name of the managed folder.
+         */
+        managedFolder?: string;
+        /**
+         * Request body metadata
+         */
+        requestBody?: Schema$ManagedFolder;
+    }
     export class Resource$Notifications {
         context: APIRequestContext;
         constructor(context: APIRequestContext);
@@ -9026,120 +9254,8 @@ export declare namespace storage_v1 {
         update(params: Params$Resource$Objects$Update, options: MethodOptions | BodyResponseCallback<Schema$Object>, callback: BodyResponseCallback<Schema$Object>): void;
         update(params: Params$Resource$Objects$Update, callback: BodyResponseCallback<Schema$Object>): void;
         update(callback: BodyResponseCallback<Schema$Object>): void;
-        /**
-         * Watch for changes on all objects in a bucket.
-         * @example
-         * ```js
-         * // Before running the sample:
-         * // - Enable the API at:
-         * //   https://console.developers.google.com/apis/api/storage.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 storage = google.storage('v1');
-         *
-         * async function main() {
-         *   const auth = new google.auth.GoogleAuth({
-         *     // Scopes can be specified either as an array or as a single, space-delimited string.
-         *     scopes: [
-         *       'https://www.googleapis.com/auth/cloud-platform',
-         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
-         *       'https://www.googleapis.com/auth/devstorage.full_control',
-         *       'https://www.googleapis.com/auth/devstorage.read_only',
-         *       'https://www.googleapis.com/auth/devstorage.read_write',
-         *     ],
-         *   });
-         *
-         *   // 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 storage.objects.watchAll({
-         *     // Name of the bucket in which to look for objects.
-         *     bucket: 'placeholder-value',
-         *     // Returns results in a directory-like mode. items will contain only objects whose names, aside from the prefix, do not contain delimiter. Objects whose names, aside from the prefix, contain delimiter will have their name, truncated after the delimiter, returned in prefixes. Duplicate prefixes are omitted.
-         *     delimiter: 'placeholder-value',
-         *     // Filter results to objects whose names are lexicographically before endOffset. If startOffset is also set, the objects listed will have names between startOffset (inclusive) and endOffset (exclusive).
-         *     endOffset: 'placeholder-value',
-         *     // If true, objects that end in exactly one instance of delimiter will have their metadata included in items in addition to prefixes.
-         *     includeTrailingDelimiter: 'placeholder-value',
-         *     // Maximum number of items plus prefixes to return in a single page of responses. As duplicate prefixes are omitted, fewer total results may be returned than requested. The service will use this parameter or 1,000 items, whichever is smaller.
-         *     maxResults: 'placeholder-value',
-         *     // A previously-returned page token representing part of the larger set of results to view.
-         *     pageToken: 'placeholder-value',
-         *     // Filter results to objects whose names begin with this prefix.
-         *     prefix: 'placeholder-value',
-         *     // Set of properties to return. Defaults to noAcl.
-         *     projection: 'placeholder-value',
-         *     // Filter results to objects whose names are lexicographically equal to or after startOffset. If endOffset is also set, the objects listed will have names between startOffset (inclusive) and endOffset (exclusive).
-         *     startOffset: 'placeholder-value',
-         *     // The project to be billed for this request. Required for Requester Pays buckets.
-         *     userProject: 'placeholder-value',
-         *     // If true, lists all versions of an object as distinct results. The default is false. For more information, see [Object Versioning](https://cloud.google.com/storage/docs/object-versioning).
-         *     versions: 'placeholder-value',
-         *
-         *     // Request body metadata
-         *     requestBody: {
-         *       // request body parameters
-         *       // {
-         *       //   "address": "my_address",
-         *       //   "expiration": "my_expiration",
-         *       //   "id": "my_id",
-         *       //   "kind": "my_kind",
-         *       //   "params": {},
-         *       //   "payload": false,
-         *       //   "resourceId": "my_resourceId",
-         *       //   "resourceUri": "my_resourceUri",
-         *       //   "token": "my_token",
-         *       //   "type": "my_type"
-         *       // }
-         *     },
-         *   });
-         *   console.log(res.data);
-         *
-         *   // Example response
-         *   // {
-         *   //   "address": "my_address",
-         *   //   "expiration": "my_expiration",
-         *   //   "id": "my_id",
-         *   //   "kind": "my_kind",
-         *   //   "params": {},
-         *   //   "payload": false,
-         *   //   "resourceId": "my_resourceId",
-         *   //   "resourceUri": "my_resourceUri",
-         *   //   "token": "my_token",
-         *   //   "type": "my_type"
-         *   // }
-         * }
-         *
-         * 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.
-         */
-        watchAll(params: Params$Resource$Objects$Watchall, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
-        watchAll(params?: Params$Resource$Objects$Watchall, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Channel>>;
-        watchAll(params: Params$Resource$Objects$Watchall, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
-        watchAll(params: Params$Resource$Objects$Watchall, options: MethodOptions | BodyResponseCallback<Schema$Channel>, callback: BodyResponseCallback<Schema$Channel>): void;
-        watchAll(params: Params$Resource$Objects$Watchall, callback: BodyResponseCallback<Schema$Channel>): void;
-        watchAll(callback: BodyResponseCallback<Schema$Channel>): void;
-    }
-    export interface Params$Resource$Objects$Bulkrestore extends StandardParameters {
+    }
+    export interface Params$Resource$Objects$Bulkrestore extends StandardParameters {
         /**
          * Name of the bucket in which the object resides.
          */
@@ -9814,56 +9930,6 @@ export declare namespace storage_v1 {
          */
         requestBody?: Schema$Object;
     }
-    export interface Params$Resource$Objects$Watchall extends StandardParameters {
-        /**
-         * Name of the bucket in which to look for objects.
-         */
-        bucket?: string;
-        /**
-         * Returns results in a directory-like mode. items will contain only objects whose names, aside from the prefix, do not contain delimiter. Objects whose names, aside from the prefix, contain delimiter will have their name, truncated after the delimiter, returned in prefixes. Duplicate prefixes are omitted.
-         */
-        delimiter?: string;
-        /**
-         * Filter results to objects whose names are lexicographically before endOffset. If startOffset is also set, the objects listed will have names between startOffset (inclusive) and endOffset (exclusive).
-         */
-        endOffset?: string;
-        /**
-         * If true, objects that end in exactly one instance of delimiter will have their metadata included in items in addition to prefixes.
-         */
-        includeTrailingDelimiter?: boolean;
-        /**
-         * Maximum number of items plus prefixes to return in a single page of responses. As duplicate prefixes are omitted, fewer total results may be returned than requested. The service will use this parameter or 1,000 items, whichever is smaller.
-         */
-        maxResults?: number;
-        /**
-         * A previously-returned page token representing part of the larger set of results to view.
-         */
-        pageToken?: string;
-        /**
-         * Filter results to objects whose names begin with this prefix.
-         */
-        prefix?: string;
-        /**
-         * Set of properties to return. Defaults to noAcl.
-         */
-        projection?: string;
-        /**
-         * Filter results to objects whose names are lexicographically equal to or after startOffset. If endOffset is also set, the objects listed will have names between startOffset (inclusive) and endOffset (exclusive).
-         */
-        startOffset?: string;
-        /**
-         * The project to be billed for this request. Required for Requester Pays buckets.
-         */
-        userProject?: string;
-        /**
-         * If true, lists all versions of an object as distinct results. The default is false. For more information, see [Object Versioning](https://cloud.google.com/storage/docs/object-versioning).
-         */
-        versions?: boolean;
-        /**
-         * Request body metadata
-         */
-        requestBody?: Schema$Channel;
-    }
     export class Resource$Operations {
         context: APIRequestContext;
         constructor(context: APIRequestContext);
@@ -10758,5 +10824,476 @@ export declare namespace storage_v1 {
          */
         userProject?: string;
     }
+    export class Resource$Rapidcaches {
+        context: APIRequestContext;
+        constructor(context: APIRequestContext);
+        /**
+         * Disables a Rapid Cache instance.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storage.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 storage = google.storage('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/devstorage.full_control',
+         *       'https://www.googleapis.com/auth/devstorage.read_write',
+         *     ],
+         *   });
+         *
+         *   // 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 storage.rapidCaches.disable({
+         *     // Name of the parent bucket.
+         *     bucket: 'placeholder-value',
+         *     // The ID of the requested Rapid Cache instance.
+         *     rapidCacheId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "done": false,
+         *   //   "error": {},
+         *   //   "kind": "my_kind",
+         *   //   "metadata": {},
+         *   //   "name": "my_name",
+         *   //   "response": {},
+         *   //   "selfLink": "my_selfLink"
+         *   // }
+         * }
+         *
+         * 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.
+         */
+        disable(params: Params$Resource$Rapidcaches$Disable, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        disable(params?: Params$Resource$Rapidcaches$Disable, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$GoogleLongrunningOperation>>;
+        disable(params: Params$Resource$Rapidcaches$Disable, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        disable(params: Params$Resource$Rapidcaches$Disable, options: MethodOptions | BodyResponseCallback<Schema$GoogleLongrunningOperation>, callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+        disable(params: Params$Resource$Rapidcaches$Disable, callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+        disable(callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+        /**
+         * Returns the metadata of a Rapid Cache instance.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storage.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 storage = google.storage('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/devstorage.full_control',
+         *       'https://www.googleapis.com/auth/devstorage.read_only',
+         *       'https://www.googleapis.com/auth/devstorage.read_write',
+         *     ],
+         *   });
+         *
+         *   // 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 storage.rapidCaches.get({
+         *     // Name of the parent bucket.
+         *     bucket: 'placeholder-value',
+         *     // The ID of the requested Rapid Cache instance.
+         *     rapidCacheId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "admissionPolicy": "my_admissionPolicy",
+         *   //   "bucket": "my_bucket",
+         *   //   "cacheType": "my_cacheType",
+         *   //   "createTime": "my_createTime",
+         *   //   "id": "my_id",
+         *   //   "ingestOnWrite": false,
+         *   //   "kind": "my_kind",
+         *   //   "pendingUpdate": false,
+         *   //   "rapidCacheId": "my_rapidCacheId",
+         *   //   "selfLink": "my_selfLink",
+         *   //   "state": "my_state",
+         *   //   "ttl": "my_ttl",
+         *   //   "updateTime": "my_updateTime",
+         *   //   "zone": "my_zone"
+         *   // }
+         * }
+         *
+         * 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$Rapidcaches$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Rapidcaches$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$RapidCache>>;
+        get(params: Params$Resource$Rapidcaches$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        get(params: Params$Resource$Rapidcaches$Get, options: MethodOptions | BodyResponseCallback<Schema$RapidCache>, callback: BodyResponseCallback<Schema$RapidCache>): void;
+        get(params: Params$Resource$Rapidcaches$Get, callback: BodyResponseCallback<Schema$RapidCache>): void;
+        get(callback: BodyResponseCallback<Schema$RapidCache>): void;
+        /**
+         * Creates a Rapid Cache instance.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storage.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 storage = google.storage('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/devstorage.full_control',
+         *       'https://www.googleapis.com/auth/devstorage.read_write',
+         *     ],
+         *   });
+         *
+         *   // 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 storage.rapidCaches.insert({
+         *     // Name of the parent bucket.
+         *     bucket: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "admissionPolicy": "my_admissionPolicy",
+         *       //   "bucket": "my_bucket",
+         *       //   "cacheType": "my_cacheType",
+         *       //   "createTime": "my_createTime",
+         *       //   "id": "my_id",
+         *       //   "ingestOnWrite": false,
+         *       //   "kind": "my_kind",
+         *       //   "pendingUpdate": false,
+         *       //   "rapidCacheId": "my_rapidCacheId",
+         *       //   "selfLink": "my_selfLink",
+         *       //   "state": "my_state",
+         *       //   "ttl": "my_ttl",
+         *       //   "updateTime": "my_updateTime",
+         *       //   "zone": "my_zone"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "done": false,
+         *   //   "error": {},
+         *   //   "kind": "my_kind",
+         *   //   "metadata": {},
+         *   //   "name": "my_name",
+         *   //   "response": {},
+         *   //   "selfLink": "my_selfLink"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
+         *
+         * @param params - Parameters for request
+         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @param callback - Optional callback that handles the response.
+         * @returns A promise if used with async/await, or void if used with a callback.
+         */
+        insert(params: Params$Resource$Rapidcaches$Insert, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        insert(params?: Params$Resource$Rapidcaches$Insert, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$GoogleLongrunningOperation>>;
+        insert(params: Params$Resource$Rapidcaches$Insert, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        insert(params: Params$Resource$Rapidcaches$Insert, options: MethodOptions | BodyResponseCallback<Schema$GoogleLongrunningOperation>, callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+        insert(params: Params$Resource$Rapidcaches$Insert, callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+        insert(callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+        /**
+         * Returns a list of Rapid Cache instances of the bucket.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storage.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 storage = google.storage('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/devstorage.full_control',
+         *       'https://www.googleapis.com/auth/devstorage.read_only',
+         *       'https://www.googleapis.com/auth/devstorage.read_write',
+         *     ],
+         *   });
+         *
+         *   // 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 storage.rapidCaches.list({
+         *     // Name of the parent bucket.
+         *     bucket: 'placeholder-value',
+         *     // Maximum number of items to return in a single page of responses.
+         *     pageSize: 'placeholder-value',
+         *     // A previously-returned page token representing part of the larger set of results to view.
+         *     pageToken: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "items": [],
+         *   //   "kind": "my_kind",
+         *   //   "nextPageToken": "my_nextPageToken"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
+         *
+         * @param params - Parameters for request
+         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @param callback - Optional callback that handles the response.
+         * @returns A promise if used with async/await, or void if used with a callback.
+         */
+        list(params: Params$Resource$Rapidcaches$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Rapidcaches$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$RapidCaches>>;
+        list(params: Params$Resource$Rapidcaches$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        list(params: Params$Resource$Rapidcaches$List, options: MethodOptions | BodyResponseCallback<Schema$RapidCaches>, callback: BodyResponseCallback<Schema$RapidCaches>): void;
+        list(params: Params$Resource$Rapidcaches$List, callback: BodyResponseCallback<Schema$RapidCaches>): void;
+        list(callback: BodyResponseCallback<Schema$RapidCaches>): void;
+        /**
+         * Updates the configuration of a Rapid Cache instance.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storage.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 storage = google.storage('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/devstorage.full_control',
+         *       'https://www.googleapis.com/auth/devstorage.read_write',
+         *     ],
+         *   });
+         *
+         *   // 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 storage.rapidCaches.update({
+         *     // Name of the parent bucket.
+         *     bucket: 'placeholder-value',
+         *     // The ID of the requested Rapid Cache instance.
+         *     rapidCacheId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "admissionPolicy": "my_admissionPolicy",
+         *       //   "bucket": "my_bucket",
+         *       //   "cacheType": "my_cacheType",
+         *       //   "createTime": "my_createTime",
+         *       //   "id": "my_id",
+         *       //   "ingestOnWrite": false,
+         *       //   "kind": "my_kind",
+         *       //   "pendingUpdate": false,
+         *       //   "rapidCacheId": "my_rapidCacheId",
+         *       //   "selfLink": "my_selfLink",
+         *       //   "state": "my_state",
+         *       //   "ttl": "my_ttl",
+         *       //   "updateTime": "my_updateTime",
+         *       //   "zone": "my_zone"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "done": false,
+         *   //   "error": {},
+         *   //   "kind": "my_kind",
+         *   //   "metadata": {},
+         *   //   "name": "my_name",
+         *   //   "response": {},
+         *   //   "selfLink": "my_selfLink"
+         *   // }
+         * }
+         *
+         * 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$Rapidcaches$Update, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        update(params?: Params$Resource$Rapidcaches$Update, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$GoogleLongrunningOperation>>;
+        update(params: Params$Resource$Rapidcaches$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        update(params: Params$Resource$Rapidcaches$Update, options: MethodOptions | BodyResponseCallback<Schema$GoogleLongrunningOperation>, callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+        update(params: Params$Resource$Rapidcaches$Update, callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+        update(callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+    }
+    export interface Params$Resource$Rapidcaches$Disable extends StandardParameters {
+        /**
+         * Name of the parent bucket.
+         */
+        bucket?: string;
+        /**
+         * The ID of the requested Rapid Cache instance.
+         */
+        rapidCacheId?: string;
+    }
+    export interface Params$Resource$Rapidcaches$Get extends StandardParameters {
+        /**
+         * Name of the parent bucket.
+         */
+        bucket?: string;
+        /**
+         * The ID of the requested Rapid Cache instance.
+         */
+        rapidCacheId?: string;
+    }
+    export interface Params$Resource$Rapidcaches$Insert extends StandardParameters {
+        /**
+         * Name of the parent bucket.
+         */
+        bucket?: string;
+        /**
+         * Request body metadata
+         */
+        requestBody?: Schema$RapidCache;
+    }
+    export interface Params$Resource$Rapidcaches$List extends StandardParameters {
+        /**
+         * Name of the parent bucket.
+         */
+        bucket?: string;
+        /**
+         * Maximum number of items to return in a single page of responses.
+         */
+        pageSize?: number;
+        /**
+         * A previously-returned page token representing part of the larger set of results to view.
+         */
+        pageToken?: string;
+    }
+    export interface Params$Resource$Rapidcaches$Update extends StandardParameters {
+        /**
+         * Name of the parent bucket.
+         */
+        bucket?: string;
+        /**
+         * The ID of the requested Rapid Cache instance.
+         */
+        rapidCacheId?: string;
+        /**
+         * Request body metadata
+         */
+        requestBody?: Schema$RapidCache;
+    }
     export {};
 }