@googleapis/storage 5.1.2 → 6.1.0

package/v1.ts

@@ -104,9 +104,11 @@ export namespace storage_v1 {
     buckets: Resource$Buckets;
     channels: Resource$Channels;
     defaultObjectAccessControls: Resource$Defaultobjectaccesscontrols;
+    managedFolders: Resource$Managedfolders;
     notifications: Resource$Notifications;
     objectAccessControls: Resource$Objectaccesscontrols;
     objects: Resource$Objects;
+    operations: Resource$Operations;
     projects: Resource$Projects;
 
     constructor(options: GlobalOptions, google?: GoogleConfigurable) {
@@ -122,11 +124,13 @@ export namespace storage_v1 {
       this.channels = new Resource$Channels(this.context);
       this.defaultObjectAccessControls =
         new Resource$Defaultobjectaccesscontrols(this.context);
+      this.managedFolders = new Resource$Managedfolders(this.context);
       this.notifications = new Resource$Notifications(this.context);
       this.objectAccessControls = new Resource$Objectaccesscontrols(
         this.context
       );
       this.objects = new Resource$Objects(this.context);
+      this.operations = new Resource$Operations(this.context);
       this.projects = new Resource$Projects(this.context);
     }
   }
@@ -142,7 +146,12 @@ export namespace storage_v1 {
     /**
      * The bucket's Autoclass configuration.
      */
-    autoclass?: {enabled?: boolean; toggleTime?: string} | null;
+    autoclass?: {
+      enabled?: boolean;
+      terminalStorageClass?: string;
+      terminalStorageClassUpdateTime?: string;
+      toggleTime?: string;
+    } | null;
     /**
      * The bucket's billing configuration.
      */
@@ -238,6 +247,10 @@ export namespace storage_v1 {
      * The name of the bucket.
      */
     name?: string | null;
+    /**
+     * The bucket's object retention config.
+     */
+    objectRetention?: {mode?: string} | null;
     /**
      * The owner of the bucket. This is always the project team's owner group.
      */
@@ -266,6 +279,13 @@ export namespace storage_v1 {
      * The URI of this bucket.
      */
     selfLink?: string | null;
+    /**
+     * The bucket's soft delete policy, which defines the period of time that soft-deleted objects will be retained, and cannot be permanently deleted.
+     */
+    softDeletePolicy?: {
+      effectiveTime?: string;
+      retentionDurationSeconds?: string;
+    } | null;
     /**
      * The bucket's default storage class, used whenever no storageClass is specified for a newly-created object. This defines how objects in the bucket are stored and determines the SLA and the cost of storage. Values include MULTI_REGIONAL, REGIONAL, STANDARD, NEARLINE, COLDLINE, ARCHIVE, and DURABLE_REDUCED_AVAILABILITY. If this value is not specified when the bucket is created, it will default to STANDARD. For more information, see storage classes.
      */
@@ -377,6 +397,31 @@ export namespace storage_v1 {
      */
     nextPageToken?: string | null;
   }
+  /**
+   * A bulk restore objects request.
+   */
+  export interface Schema$BulkRestoreObjectsRequest {
+    /**
+     * If false (default), the restore will not overwrite live objects with the same name at the destination. This means some deleted objects may be skipped. If true, live objects will be overwritten resulting in a noncurrent object (if versioning is enabled). If versioning is not enabled, overwriting the object will result in a soft-deleted object. In either case, if a noncurrent object already exists with the same name, a live version can be written without issue.
+     */
+    allowOverwrite?: boolean | null;
+    /**
+     * If true, copies the source object's ACL; otherwise, uses the bucket's default object ACL. The default is false.
+     */
+    copySourceAcl?: boolean | null;
+    /**
+     * Restores only the objects matching any of the specified glob(s). If this parameter is not specified, all objects will be restored within the specified time range.
+     */
+    matchGlobs?: string[] | null;
+    /**
+     * Restores only the objects that were soft-deleted after this time.
+     */
+    softDeletedAfterTime?: string | null;
+    /**
+     * Restores only the objects that were soft-deleted before this time.
+     */
+    softDeletedBeforeTime?: string | null;
+  }
   /**
    * An notification channel used to watch for resource changes.
    */
@@ -464,6 +509,61 @@ export namespace storage_v1 {
      */
     title?: string | null;
   }
+  /**
+   * The response message for storage.buckets.operations.list.
+   */
+  export interface Schema$GoogleLongrunningListOperationsResponse {
+    /**
+     * 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 list of operations that matches the specified filter in the request.
+     */
+    operations?: Schema$GoogleLongrunningOperation[];
+  }
+  /**
+   * This resource represents a long-running operation that is the result of a network API call.
+   */
+  export interface Schema$GoogleLongrunningOperation {
+    /**
+     * If the value is "false", it means the operation is still in progress. If "true", the operation is completed, and either "error" or "response" is available.
+     */
+    done?: boolean | null;
+    /**
+     * The error result of the operation in case of failure or cancellation.
+     */
+    error?: Schema$GoogleRpcStatus;
+    /**
+     * Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.
+     */
+    metadata?: {[key: string]: any} | null;
+    /**
+     * The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the "name" should be a resource name ending with "operations/{operationId\}".
+     */
+    name?: string | null;
+    /**
+     * The normal response of the operation in case of success. If the original method returns no data on success, such as "Delete", the response is google.protobuf.Empty. If the original method is standard Get/Create/Update, the response should be the resource. For other methods, the response should have the type "XxxResponse", where "Xxx" is the original method name. For example, if the original method name is "TakeSnapshot()", the inferred response type is "TakeSnapshotResponse".
+     */
+    response?: {[key: string]: any} | null;
+  }
+  /**
+   * The "Status" type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each "Status" message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).
+   */
+  export interface Schema$GoogleRpcStatus {
+    /**
+     * The status code, which should be an enum value of google.rpc.Code.
+     */
+    code?: number | null;
+    /**
+     * A list of messages that carry the error details. There is a common set of message types for APIs to use.
+     */
+    details?: Array<{[key: string]: any}> | null;
+    /**
+     * A developer-facing error message, which should be in English.
+     */
+    message?: string | null;
+  }
   /**
    * JSON template to produce a JSON-style HMAC Key resource for Create responses.
    */
@@ -543,6 +643,60 @@ export namespace storage_v1 {
      */
     nextPageToken?: string | null;
   }
+  /**
+   * A managed folder.
+   */
+  export interface Schema$ManagedFolder {
+    /**
+     * The name of the bucket containing this managed folder.
+     */
+    bucket?: string | null;
+    /**
+     * The creation time of the managed folder in RFC 3339 format.
+     */
+    createTime?: string | null;
+    /**
+     * The ID of the managed folder, including the bucket name and managed folder name.
+     */
+    id?: string | null;
+    /**
+     * The kind of item this is. For managed folders, this is always storage#managedFolder.
+     */
+    kind?: string | null;
+    /**
+     * The version of the metadata for this managed folder. Used for preconditions and for detecting changes in metadata.
+     */
+    metageneration?: string | null;
+    /**
+     * The name of the managed folder. Required if not specified by URL parameter.
+     */
+    name?: string | null;
+    /**
+     * The link to this managed folder.
+     */
+    selfLink?: string | null;
+    /**
+     * The last update time of the managed folder metadata in RFC 3339 format.
+     */
+    updateTime?: string | null;
+  }
+  /**
+   * A list of managed folders.
+   */
+  export interface Schema$ManagedFolders {
+    /**
+     * The list of items.
+     */
+    items?: Schema$ManagedFolder[];
+    /**
+     * The kind of item this is. For lists of managed folders, this is always storage#managedFolders.
+     */
+    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 subscription to receive Google PubSub notifications.
    */
@@ -660,6 +814,10 @@ export namespace storage_v1 {
      * The content generation of this object. Used for object versioning.
      */
     generation?: string | null;
+    /**
+     * This is the time (in the future) when the soft-deleted object will no longer be restorable. It is equal to the soft delete time plus the current soft delete retention duration of the bucket.
+     */
+    hardDeleteTime?: string | null;
     /**
      * The ID of the object, including the bucket name, object name, and generation number.
      */
@@ -696,6 +854,10 @@ export namespace storage_v1 {
      * The owner of the object. This will always be the uploader of the object.
      */
     owner?: {entity?: string; entityId?: string} | null;
+    /**
+     * A collection of object level retention parameters.
+     */
+    retention?: {mode?: string; retainUntilTime?: string} | null;
     /**
      * A server-determined value that specifies the earliest time that the object's retention period expires. This value is in RFC 3339 format. Note 1: This field is not provided for objects with an active event-based hold, since retention expiration is unknown until the hold is removed. Note 2: This value can be provided even when temporary hold is set (so that the user can reason about policy without having to first unset the temporary hold).
      */
@@ -708,6 +870,10 @@ export namespace storage_v1 {
      * Content-Length of the data in bytes.
      */
     size?: string | null;
+    /**
+     * The time at which the object became soft-deleted in RFC 3339 format.
+     */
+    softDeleteTime?: string | null;
     /**
      * Storage class of the object.
      */
@@ -721,7 +887,7 @@ export namespace storage_v1 {
      */
     timeCreated?: string | null;
     /**
-     * The deletion time of the object in RFC 3339 format. Will be returned if and only if this version of the object has been deleted.
+     * The time at which the object became noncurrent in RFC 3339 format. Will be returned if and only if this version of the object has been deleted.
      */
     timeDeleted?: string | null;
     /**
@@ -836,7 +1002,7 @@ export namespace storage_v1 {
     prefixes?: string[] | null;
   }
   /**
-   * A bucket/object IAM policy.
+   * A bucket/object/managedFolder IAM policy.
    */
   export interface Schema$Policy {
     /**
@@ -856,7 +1022,7 @@ export namespace storage_v1 {
      */
     kind?: string | null;
     /**
-     * The ID of the resource to which this policy belongs. Will be of the form projects/_/buckets/bucket for buckets, and projects/_/buckets/bucket/objects/object for objects. A specific generation may be specified by appending #generationNumber to the end of the object name, e.g. projects/_/buckets/my-bucket/objects/data.txt#17. The current generation can be denoted with #0. This field is ignored on input.
+     * The ID of the resource to which this policy belongs. Will be of the form projects/_/buckets/bucket for buckets, projects/_/buckets/bucket/objects/object for objects, and projects/_/buckets/bucket/managedFolders/managedFolder. A specific generation may be specified by appending #generationNumber to the end of the object name, e.g. projects/_/buckets/my-bucket/objects/data.txt#17. The current generation can be denoted with #0. This field is ignored on input.
      */
     resourceId?: string | null;
     /**
@@ -907,7 +1073,7 @@ export namespace storage_v1 {
     kind?: string | null;
   }
   /**
-   * A storage.(buckets|objects).testIamPermissions response.
+   * A storage.(buckets|objects|managedFolders).testIamPermissions response.
    */
   export interface Schema$TestIamPermissionsResponse {
     /**
@@ -915,7 +1081,7 @@ export namespace storage_v1 {
      */
     kind?: string | null;
     /**
-     * The permissions held by the caller. Permissions are always of the format storage.resource.capability, where resource is one of buckets or objects. The supported permissions are as follows:
+     * The permissions held by the caller. Permissions are always of the format storage.resource.capability, where resource is one of buckets, objects, or managedFolders. The supported permissions are as follows:
      * - storage.buckets.delete — Delete bucket.
      * - storage.buckets.get — Read bucket metadata.
      * - storage.buckets.getIamPolicy — Read bucket IAM policy.
@@ -930,6 +1096,12 @@ export namespace storage_v1 {
      * - storage.objects.list — List objects.
      * - storage.objects.setIamPolicy — Update object IAM policy.
      * - storage.objects.update — Update object metadata.
+     * - storage.managedFolders.delete — Delete managed folder.
+     * - storage.managedFolders.get — Read managed folder metadata.
+     * - storage.managedFolders.getIamPolicy — Read managed folder IAM policy.
+     * - storage.managedFolders.create — Create managed folder.
+     * - storage.managedFolders.list — List managed folders.
+     * - storage.managedFolders.setIamPolicy — Update managed folder IAM policy.
      */
     permissions?: string[] | null;
   }
@@ -2500,6 +2672,10 @@ export namespace storage_v1 {
     userProject?: string;
   }
   export interface Params$Resource$Buckets$Insert extends StandardParameters {
+    /**
+     * When set to true, object retention is enabled for this bucket.
+     */
+    enableObjectRetention?: boolean;
     /**
      * Apply a predefined set of access controls to this bucket.
      */
@@ -3413,14 +3589,14 @@ export namespace storage_v1 {
     requestBody?: Schema$ObjectAccessControl;
   }
 
-  export class Resource$Notifications {
+  export class Resource$Managedfolders {
     context: APIRequestContext;
     constructor(context: APIRequestContext) {
       this.context = context;
     }
 
     /**
-     * Permanently deletes a notification subscription.
+     * Permanently deletes a managed folder.
      *
      * @param params - Parameters for request
      * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -3428,31 +3604,31 @@ export namespace storage_v1 {
      * @returns A promise if used with async/await, or void if used with a callback.
      */
     delete(
-      params: Params$Resource$Notifications$Delete,
+      params: Params$Resource$Managedfolders$Delete,
       options: StreamMethodOptions
     ): GaxiosPromise<Readable>;
     delete(
-      params?: Params$Resource$Notifications$Delete,
+      params?: Params$Resource$Managedfolders$Delete,
       options?: MethodOptions
     ): GaxiosPromise<void>;
     delete(
-      params: Params$Resource$Notifications$Delete,
+      params: Params$Resource$Managedfolders$Delete,
       options: StreamMethodOptions | BodyResponseCallback<Readable>,
       callback: BodyResponseCallback<Readable>
     ): void;
     delete(
-      params: Params$Resource$Notifications$Delete,
+      params: Params$Resource$Managedfolders$Delete,
       options: MethodOptions | BodyResponseCallback<void>,
       callback: BodyResponseCallback<void>
     ): void;
     delete(
-      params: Params$Resource$Notifications$Delete,
+      params: Params$Resource$Managedfolders$Delete,
       callback: BodyResponseCallback<void>
     ): void;
     delete(callback: BodyResponseCallback<void>): void;
     delete(
       paramsOrCallback?:
-        | Params$Resource$Notifications$Delete
+        | Params$Resource$Managedfolders$Delete
         | BodyResponseCallback<void>
         | BodyResponseCallback<Readable>,
       optionsOrCallback?:
@@ -3463,12 +3639,12 @@ export namespace storage_v1 {
       callback?: BodyResponseCallback<void> | BodyResponseCallback<Readable>
     ): void | GaxiosPromise<void> | GaxiosPromise<Readable> {
       let params = (paramsOrCallback ||
-        {}) as Params$Resource$Notifications$Delete;
+        {}) as Params$Resource$Managedfolders$Delete;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
-        params = {} as Params$Resource$Notifications$Delete;
+        params = {} as Params$Resource$Managedfolders$Delete;
         options = {};
       }
 
@@ -3482,16 +3658,15 @@ export namespace storage_v1 {
         options: Object.assign(
           {
             url: (
-              rootUrl +
-              '/storage/v1/b/{bucket}/notificationConfigs/{notification}'
+              rootUrl + '/storage/v1/b/{bucket}/managedFolders/{managedFolder}'
             ).replace(/([^:]\/)\/+/g, '$1'),
             method: 'DELETE',
           },
           options
         ),
         params,
-        requiredParams: ['bucket', 'notification'],
-        pathParams: ['bucket', 'notification'],
+        requiredParams: ['bucket', 'managedFolder'],
+        pathParams: ['bucket', 'managedFolder'],
         context: this.context,
       };
       if (callback) {
@@ -3505,7 +3680,7 @@ export namespace storage_v1 {
     }
 
     /**
-     * View a notification configuration.
+     * Returns metadata of the specified managed folder.
      *
      * @param params - Parameters for request
      * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -3513,49 +3688,49 @@ export namespace storage_v1 {
      * @returns A promise if used with async/await, or void if used with a callback.
      */
     get(
-      params: Params$Resource$Notifications$Get,
+      params: Params$Resource$Managedfolders$Get,
       options: StreamMethodOptions
     ): GaxiosPromise<Readable>;
     get(
-      params?: Params$Resource$Notifications$Get,
+      params?: Params$Resource$Managedfolders$Get,
       options?: MethodOptions
-    ): GaxiosPromise<Schema$Notification>;
+    ): GaxiosPromise<Schema$ManagedFolder>;
     get(
-      params: Params$Resource$Notifications$Get,
+      params: Params$Resource$Managedfolders$Get,
       options: StreamMethodOptions | BodyResponseCallback<Readable>,
       callback: BodyResponseCallback<Readable>
     ): void;
     get(
-      params: Params$Resource$Notifications$Get,
-      options: MethodOptions | BodyResponseCallback<Schema$Notification>,
-      callback: BodyResponseCallback<Schema$Notification>
+      params: Params$Resource$Managedfolders$Get,
+      options: MethodOptions | BodyResponseCallback<Schema$ManagedFolder>,
+      callback: BodyResponseCallback<Schema$ManagedFolder>
     ): void;
     get(
-      params: Params$Resource$Notifications$Get,
-      callback: BodyResponseCallback<Schema$Notification>
+      params: Params$Resource$Managedfolders$Get,
+      callback: BodyResponseCallback<Schema$ManagedFolder>
     ): void;
-    get(callback: BodyResponseCallback<Schema$Notification>): void;
+    get(callback: BodyResponseCallback<Schema$ManagedFolder>): void;
     get(
       paramsOrCallback?:
-        | Params$Resource$Notifications$Get
-        | BodyResponseCallback<Schema$Notification>
+        | Params$Resource$Managedfolders$Get
+        | BodyResponseCallback<Schema$ManagedFolder>
         | BodyResponseCallback<Readable>,
       optionsOrCallback?:
         | MethodOptions
         | StreamMethodOptions
-        | BodyResponseCallback<Schema$Notification>
+        | BodyResponseCallback<Schema$ManagedFolder>
         | BodyResponseCallback<Readable>,
       callback?:
-        | BodyResponseCallback<Schema$Notification>
+        | BodyResponseCallback<Schema$ManagedFolder>
         | BodyResponseCallback<Readable>
-    ): void | GaxiosPromise<Schema$Notification> | GaxiosPromise<Readable> {
+    ): void | GaxiosPromise<Schema$ManagedFolder> | GaxiosPromise<Readable> {
       let params = (paramsOrCallback ||
-        {}) as Params$Resource$Notifications$Get;
+        {}) as Params$Resource$Managedfolders$Get;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
-        params = {} as Params$Resource$Notifications$Get;
+        params = {} as Params$Resource$Managedfolders$Get;
         options = {};
       }
 
@@ -3569,80 +3744,79 @@ export namespace storage_v1 {
         options: Object.assign(
           {
             url: (
-              rootUrl +
-              '/storage/v1/b/{bucket}/notificationConfigs/{notification}'
+              rootUrl + '/storage/v1/b/{bucket}/managedFolders/{managedFolder}'
             ).replace(/([^:]\/)\/+/g, '$1'),
             method: 'GET',
           },
           options
         ),
         params,
-        requiredParams: ['bucket', 'notification'],
-        pathParams: ['bucket', 'notification'],
+        requiredParams: ['bucket', 'managedFolder'],
+        pathParams: ['bucket', 'managedFolder'],
         context: this.context,
       };
       if (callback) {
-        createAPIRequest<Schema$Notification>(
+        createAPIRequest<Schema$ManagedFolder>(
           parameters,
           callback as BodyResponseCallback<unknown>
         );
       } else {
-        return createAPIRequest<Schema$Notification>(parameters);
+        return createAPIRequest<Schema$ManagedFolder>(parameters);
       }
     }
 
     /**
-     * Creates a notification subscription for a given bucket.
+     * Returns an IAM policy for the specified managed folder.
      *
      * @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$Notifications$Insert,
+    getIamPolicy(
+      params: Params$Resource$Managedfolders$Getiampolicy,
       options: StreamMethodOptions
     ): GaxiosPromise<Readable>;
-    insert(
-      params?: Params$Resource$Notifications$Insert,
+    getIamPolicy(
+      params?: Params$Resource$Managedfolders$Getiampolicy,
       options?: MethodOptions
-    ): GaxiosPromise<Schema$Notification>;
-    insert(
-      params: Params$Resource$Notifications$Insert,
+    ): GaxiosPromise<Schema$Policy>;
+    getIamPolicy(
+      params: Params$Resource$Managedfolders$Getiampolicy,
       options: StreamMethodOptions | BodyResponseCallback<Readable>,
       callback: BodyResponseCallback<Readable>
     ): void;
-    insert(
-      params: Params$Resource$Notifications$Insert,
-      options: MethodOptions | BodyResponseCallback<Schema$Notification>,
-      callback: BodyResponseCallback<Schema$Notification>
+    getIamPolicy(
+      params: Params$Resource$Managedfolders$Getiampolicy,
+      options: MethodOptions | BodyResponseCallback<Schema$Policy>,
+      callback: BodyResponseCallback<Schema$Policy>
     ): void;
-    insert(
-      params: Params$Resource$Notifications$Insert,
-      callback: BodyResponseCallback<Schema$Notification>
+    getIamPolicy(
+      params: Params$Resource$Managedfolders$Getiampolicy,
+      callback: BodyResponseCallback<Schema$Policy>
     ): void;
-    insert(callback: BodyResponseCallback<Schema$Notification>): void;
-    insert(
+    getIamPolicy(callback: BodyResponseCallback<Schema$Policy>): void;
+    getIamPolicy(
       paramsOrCallback?:
-        | Params$Resource$Notifications$Insert
-        | BodyResponseCallback<Schema$Notification>
+        | Params$Resource$Managedfolders$Getiampolicy
+        | BodyResponseCallback<Schema$Policy>
         | BodyResponseCallback<Readable>,
       optionsOrCallback?:
         | MethodOptions
         | StreamMethodOptions
-        | BodyResponseCallback<Schema$Notification>
+        | BodyResponseCallback<Schema$Policy>
         | BodyResponseCallback<Readable>,
       callback?:
-        | BodyResponseCallback<Schema$Notification>
+        | BodyResponseCallback<Schema$Policy>
         | BodyResponseCallback<Readable>
-    ): void | GaxiosPromise<Schema$Notification> | GaxiosPromise<Readable> {
+    ): void | GaxiosPromise<Schema$Policy> | GaxiosPromise<Readable> {
       let params = (paramsOrCallback ||
-        {}) as Params$Resource$Notifications$Insert;
+        {}) as Params$Resource$Managedfolders$Getiampolicy;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
-        params = {} as Params$Resource$Notifications$Insert;
+        params = {} as Params$Resource$Managedfolders$Getiampolicy;
         options = {};
       }
 
@@ -3656,79 +3830,80 @@ export namespace storage_v1 {
         options: Object.assign(
           {
             url: (
-              rootUrl + '/storage/v1/b/{bucket}/notificationConfigs'
+              rootUrl +
+              '/storage/v1/b/{bucket}/managedFolders/{managedFolder}/iam'
             ).replace(/([^:]\/)\/+/g, '$1'),
-            method: 'POST',
+            method: 'GET',
           },
           options
         ),
         params,
-        requiredParams: ['bucket'],
-        pathParams: ['bucket'],
+        requiredParams: ['bucket', 'managedFolder'],
+        pathParams: ['bucket', 'managedFolder'],
         context: this.context,
       };
       if (callback) {
-        createAPIRequest<Schema$Notification>(
+        createAPIRequest<Schema$Policy>(
           parameters,
           callback as BodyResponseCallback<unknown>
         );
       } else {
-        return createAPIRequest<Schema$Notification>(parameters);
+        return createAPIRequest<Schema$Policy>(parameters);
       }
     }
 
     /**
-     * Retrieves a list of notification subscriptions for a given bucket.
+     * Creates a new managed folder.
      *
      * @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$Notifications$List,
+    insert(
+      params: Params$Resource$Managedfolders$Insert,
       options: StreamMethodOptions
     ): GaxiosPromise<Readable>;
-    list(
-      params?: Params$Resource$Notifications$List,
+    insert(
+      params?: Params$Resource$Managedfolders$Insert,
       options?: MethodOptions
-    ): GaxiosPromise<Schema$Notifications>;
-    list(
-      params: Params$Resource$Notifications$List,
+    ): GaxiosPromise<Schema$ManagedFolder>;
+    insert(
+      params: Params$Resource$Managedfolders$Insert,
       options: StreamMethodOptions | BodyResponseCallback<Readable>,
       callback: BodyResponseCallback<Readable>
     ): void;
-    list(
-      params: Params$Resource$Notifications$List,
-      options: MethodOptions | BodyResponseCallback<Schema$Notifications>,
-      callback: BodyResponseCallback<Schema$Notifications>
+    insert(
+      params: Params$Resource$Managedfolders$Insert,
+      options: MethodOptions | BodyResponseCallback<Schema$ManagedFolder>,
+      callback: BodyResponseCallback<Schema$ManagedFolder>
     ): void;
-    list(
-      params: Params$Resource$Notifications$List,
-      callback: BodyResponseCallback<Schema$Notifications>
+    insert(
+      params: Params$Resource$Managedfolders$Insert,
+      callback: BodyResponseCallback<Schema$ManagedFolder>
     ): void;
-    list(callback: BodyResponseCallback<Schema$Notifications>): void;
-    list(
+    insert(callback: BodyResponseCallback<Schema$ManagedFolder>): void;
+    insert(
       paramsOrCallback?:
-        | Params$Resource$Notifications$List
-        | BodyResponseCallback<Schema$Notifications>
+        | Params$Resource$Managedfolders$Insert
+        | BodyResponseCallback<Schema$ManagedFolder>
         | BodyResponseCallback<Readable>,
       optionsOrCallback?:
         | MethodOptions
         | StreamMethodOptions
-        | BodyResponseCallback<Schema$Notifications>
+        | BodyResponseCallback<Schema$ManagedFolder>
         | BodyResponseCallback<Readable>,
       callback?:
-        | BodyResponseCallback<Schema$Notifications>
+        | BodyResponseCallback<Schema$ManagedFolder>
         | BodyResponseCallback<Readable>
-    ): void | GaxiosPromise<Schema$Notifications> | GaxiosPromise<Readable> {
+    ): void | GaxiosPromise<Schema$ManagedFolder> | GaxiosPromise<Readable> {
       let params = (paramsOrCallback ||
-        {}) as Params$Resource$Notifications$List;
+        {}) as Params$Resource$Managedfolders$Insert;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
-        params = {} as Params$Resource$Notifications$List;
+        params = {} as Params$Resource$Managedfolders$Insert;
         options = {};
       }
 
@@ -3741,10 +3916,11 @@ export namespace storage_v1 {
       const parameters = {
         options: Object.assign(
           {
-            url: (
-              rootUrl + '/storage/v1/b/{bucket}/notificationConfigs'
-            ).replace(/([^:]\/)\/+/g, '$1'),
-            method: 'GET',
+            url: (rootUrl + '/storage/v1/b/{bucket}/managedFolders').replace(
+              /([^:]\/)\/+/g,
+              '$1'
+            ),
+            method: 'POST',
           },
           options
         ),
@@ -3754,42 +3930,789 @@ export namespace storage_v1 {
         context: this.context,
       };
       if (callback) {
-        createAPIRequest<Schema$Notifications>(
+        createAPIRequest<Schema$ManagedFolder>(
           parameters,
           callback as BodyResponseCallback<unknown>
         );
       } else {
-        return createAPIRequest<Schema$Notifications>(parameters);
+        return createAPIRequest<Schema$ManagedFolder>(parameters);
       }
     }
-  }
 
-  export interface Params$Resource$Notifications$Delete
-    extends StandardParameters {
-    /**
-     * The parent bucket of the notification.
-     */
-    bucket?: string;
-    /**
-     * ID of the notification to delete.
-     */
-    notification?: string;
-    /**
-     * The project to be billed for this request. Required for Requester Pays buckets.
-     */
-    userProject?: string;
-  }
-  export interface Params$Resource$Notifications$Get
-    extends StandardParameters {
-    /**
-     * The parent bucket of the notification.
-     */
-    bucket?: string;
     /**
-     * Notification ID
+     * Lists managed folders in the given bucket.
+     *
+     * @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.
      */
-    notification?: string;
-    /**
+    list(
+      params: Params$Resource$Managedfolders$List,
+      options: StreamMethodOptions
+    ): GaxiosPromise<Readable>;
+    list(
+      params?: Params$Resource$Managedfolders$List,
+      options?: MethodOptions
+    ): GaxiosPromise<Schema$ManagedFolders>;
+    list(
+      params: Params$Resource$Managedfolders$List,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    list(
+      params: Params$Resource$Managedfolders$List,
+      options: MethodOptions | BodyResponseCallback<Schema$ManagedFolders>,
+      callback: BodyResponseCallback<Schema$ManagedFolders>
+    ): void;
+    list(
+      params: Params$Resource$Managedfolders$List,
+      callback: BodyResponseCallback<Schema$ManagedFolders>
+    ): void;
+    list(callback: BodyResponseCallback<Schema$ManagedFolders>): void;
+    list(
+      paramsOrCallback?:
+        | Params$Resource$Managedfolders$List
+        | BodyResponseCallback<Schema$ManagedFolders>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$ManagedFolders>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$ManagedFolders>
+        | BodyResponseCallback<Readable>
+    ): void | GaxiosPromise<Schema$ManagedFolders> | GaxiosPromise<Readable> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Managedfolders$List;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Managedfolders$List;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://storage.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (rootUrl + '/storage/v1/b/{bucket}/managedFolders').replace(
+              /([^:]\/)\/+/g,
+              '$1'
+            ),
+            method: 'GET',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['bucket'],
+        pathParams: ['bucket'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$ManagedFolders>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$ManagedFolders>(parameters);
+      }
+    }
+
+    /**
+     * Updates an IAM policy for the specified managed folder.
+     *
+     * @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.
+     */
+    setIamPolicy(
+      params: Params$Resource$Managedfolders$Setiampolicy,
+      options: StreamMethodOptions
+    ): GaxiosPromise<Readable>;
+    setIamPolicy(
+      params?: Params$Resource$Managedfolders$Setiampolicy,
+      options?: MethodOptions
+    ): GaxiosPromise<Schema$Policy>;
+    setIamPolicy(
+      params: Params$Resource$Managedfolders$Setiampolicy,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    setIamPolicy(
+      params: Params$Resource$Managedfolders$Setiampolicy,
+      options: MethodOptions | BodyResponseCallback<Schema$Policy>,
+      callback: BodyResponseCallback<Schema$Policy>
+    ): void;
+    setIamPolicy(
+      params: Params$Resource$Managedfolders$Setiampolicy,
+      callback: BodyResponseCallback<Schema$Policy>
+    ): void;
+    setIamPolicy(callback: BodyResponseCallback<Schema$Policy>): void;
+    setIamPolicy(
+      paramsOrCallback?:
+        | Params$Resource$Managedfolders$Setiampolicy
+        | BodyResponseCallback<Schema$Policy>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$Policy>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$Policy>
+        | BodyResponseCallback<Readable>
+    ): void | GaxiosPromise<Schema$Policy> | GaxiosPromise<Readable> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Managedfolders$Setiampolicy;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Managedfolders$Setiampolicy;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://storage.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl +
+              '/storage/v1/b/{bucket}/managedFolders/{managedFolder}/iam'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'PUT',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['bucket', 'managedFolder'],
+        pathParams: ['bucket', 'managedFolder'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$Policy>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$Policy>(parameters);
+      }
+    }
+
+    /**
+     * Tests a set of permissions on the given managed folder to see which, if any, are held by the caller.
+     *
+     * @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.
+     */
+    testIamPermissions(
+      params: Params$Resource$Managedfolders$Testiampermissions,
+      options: StreamMethodOptions
+    ): GaxiosPromise<Readable>;
+    testIamPermissions(
+      params?: Params$Resource$Managedfolders$Testiampermissions,
+      options?: MethodOptions
+    ): GaxiosPromise<Schema$TestIamPermissionsResponse>;
+    testIamPermissions(
+      params: Params$Resource$Managedfolders$Testiampermissions,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    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;
+    testIamPermissions(
+      paramsOrCallback?:
+        | Params$Resource$Managedfolders$Testiampermissions
+        | BodyResponseCallback<Schema$TestIamPermissionsResponse>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$TestIamPermissionsResponse>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$TestIamPermissionsResponse>
+        | BodyResponseCallback<Readable>
+    ):
+      | void
+      | GaxiosPromise<Schema$TestIamPermissionsResponse>
+      | GaxiosPromise<Readable> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Managedfolders$Testiampermissions;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Managedfolders$Testiampermissions;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://storage.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl +
+              '/storage/v1/b/{bucket}/managedFolders/{managedFolder}/iam/testPermissions'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'GET',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['bucket', 'managedFolder', 'permissions'],
+        pathParams: ['bucket', 'managedFolder'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$TestIamPermissionsResponse>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$TestIamPermissionsResponse>(parameters);
+      }
+    }
+  }
+
+  export interface Params$Resource$Managedfolders$Delete
+    extends StandardParameters {
+    /**
+     * Name of the bucket containing the managed folder.
+     */
+    bucket?: string;
+    /**
+     * If set, only deletes the managed folder if its metageneration matches this value.
+     */
+    ifMetagenerationMatch?: string;
+    /**
+     * If set, only deletes the managed folder if its metageneration does not match this value.
+     */
+    ifMetagenerationNotMatch?: string;
+    /**
+     * The managed folder name/path.
+     */
+    managedFolder?: string;
+  }
+  export interface Params$Resource$Managedfolders$Get
+    extends StandardParameters {
+    /**
+     * Name of the bucket containing the managed folder.
+     */
+    bucket?: string;
+    /**
+     * Makes the return of the managed folder metadata conditional on whether the managed folder's current metageneration matches the given value.
+     */
+    ifMetagenerationMatch?: string;
+    /**
+     * Makes the return of the managed folder metadata conditional on whether the managed folder's current metageneration does not match the given value.
+     */
+    ifMetagenerationNotMatch?: string;
+    /**
+     * The managed folder name/path.
+     */
+    managedFolder?: string;
+  }
+  export interface Params$Resource$Managedfolders$Getiampolicy
+    extends StandardParameters {
+    /**
+     * Name of the bucket containing the managed folder.
+     */
+    bucket?: string;
+    /**
+     * The managed folder name/path.
+     */
+    managedFolder?: string;
+    /**
+     * The IAM policy format version to be returned. If the optionsRequestedPolicyVersion is for an older version that doesn't support part of the requested IAM policy, the request fails.
+     */
+    optionsRequestedPolicyVersion?: number;
+    /**
+     * The project to be billed for this request. Required for Requester Pays buckets.
+     */
+    userProject?: string;
+  }
+  export interface Params$Resource$Managedfolders$Insert
+    extends StandardParameters {
+    /**
+     * Name of the bucket containing the managed folder.
+     */
+    bucket?: string;
+
+    /**
+     * Request body metadata
+     */
+    requestBody?: Schema$ManagedFolder;
+  }
+  export interface Params$Resource$Managedfolders$List
+    extends StandardParameters {
+    /**
+     * Name of the bucket containing the managed folder.
+     */
+    bucket?: string;
+    /**
+     * Maximum number of items 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;
+    /**
+     * The managed folder name/path prefix to filter the output list of results.
+     */
+    prefix?: string;
+  }
+  export interface Params$Resource$Managedfolders$Setiampolicy
+    extends StandardParameters {
+    /**
+     * Name of the bucket containing the managed folder.
+     */
+    bucket?: string;
+    /**
+     * The managed folder name/path.
+     */
+    managedFolder?: string;
+    /**
+     * The project to be billed for this request. Required for Requester Pays buckets.
+     */
+    userProject?: string;
+
+    /**
+     * Request body metadata
+     */
+    requestBody?: Schema$Policy;
+  }
+  export interface Params$Resource$Managedfolders$Testiampermissions
+    extends StandardParameters {
+    /**
+     * Name of the bucket containing the managed folder.
+     */
+    bucket?: string;
+    /**
+     * The managed folder name/path.
+     */
+    managedFolder?: string;
+    /**
+     * Permissions to test.
+     */
+    permissions?: string[];
+    /**
+     * The project to be billed for this request. Required for Requester Pays buckets.
+     */
+    userProject?: string;
+  }
+
+  export class Resource$Notifications {
+    context: APIRequestContext;
+    constructor(context: APIRequestContext) {
+      this.context = context;
+    }
+
+    /**
+     * Permanently deletes a notification subscription.
+     *
+     * @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$Notifications$Delete,
+      options: StreamMethodOptions
+    ): GaxiosPromise<Readable>;
+    delete(
+      params?: Params$Resource$Notifications$Delete,
+      options?: MethodOptions
+    ): GaxiosPromise<void>;
+    delete(
+      params: Params$Resource$Notifications$Delete,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    delete(
+      params: Params$Resource$Notifications$Delete,
+      options: MethodOptions | BodyResponseCallback<void>,
+      callback: BodyResponseCallback<void>
+    ): void;
+    delete(
+      params: Params$Resource$Notifications$Delete,
+      callback: BodyResponseCallback<void>
+    ): void;
+    delete(callback: BodyResponseCallback<void>): void;
+    delete(
+      paramsOrCallback?:
+        | Params$Resource$Notifications$Delete
+        | BodyResponseCallback<void>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<void>
+        | BodyResponseCallback<Readable>,
+      callback?: BodyResponseCallback<void> | BodyResponseCallback<Readable>
+    ): void | GaxiosPromise<void> | GaxiosPromise<Readable> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Notifications$Delete;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Notifications$Delete;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://storage.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl +
+              '/storage/v1/b/{bucket}/notificationConfigs/{notification}'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'DELETE',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['bucket', 'notification'],
+        pathParams: ['bucket', 'notification'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<void>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<void>(parameters);
+      }
+    }
+
+    /**
+     * View a notification configuration.
+     *
+     * @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$Notifications$Get,
+      options: StreamMethodOptions
+    ): GaxiosPromise<Readable>;
+    get(
+      params?: Params$Resource$Notifications$Get,
+      options?: MethodOptions
+    ): GaxiosPromise<Schema$Notification>;
+    get(
+      params: Params$Resource$Notifications$Get,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    get(
+      params: Params$Resource$Notifications$Get,
+      options: MethodOptions | BodyResponseCallback<Schema$Notification>,
+      callback: BodyResponseCallback<Schema$Notification>
+    ): void;
+    get(
+      params: Params$Resource$Notifications$Get,
+      callback: BodyResponseCallback<Schema$Notification>
+    ): void;
+    get(callback: BodyResponseCallback<Schema$Notification>): void;
+    get(
+      paramsOrCallback?:
+        | Params$Resource$Notifications$Get
+        | BodyResponseCallback<Schema$Notification>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$Notification>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$Notification>
+        | BodyResponseCallback<Readable>
+    ): void | GaxiosPromise<Schema$Notification> | GaxiosPromise<Readable> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Notifications$Get;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Notifications$Get;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://storage.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl +
+              '/storage/v1/b/{bucket}/notificationConfigs/{notification}'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'GET',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['bucket', 'notification'],
+        pathParams: ['bucket', 'notification'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$Notification>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$Notification>(parameters);
+      }
+    }
+
+    /**
+     * Creates a notification subscription for a given bucket.
+     *
+     * @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$Notifications$Insert,
+      options: StreamMethodOptions
+    ): GaxiosPromise<Readable>;
+    insert(
+      params?: Params$Resource$Notifications$Insert,
+      options?: MethodOptions
+    ): GaxiosPromise<Schema$Notification>;
+    insert(
+      params: Params$Resource$Notifications$Insert,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    insert(
+      params: Params$Resource$Notifications$Insert,
+      options: MethodOptions | BodyResponseCallback<Schema$Notification>,
+      callback: BodyResponseCallback<Schema$Notification>
+    ): void;
+    insert(
+      params: Params$Resource$Notifications$Insert,
+      callback: BodyResponseCallback<Schema$Notification>
+    ): void;
+    insert(callback: BodyResponseCallback<Schema$Notification>): void;
+    insert(
+      paramsOrCallback?:
+        | Params$Resource$Notifications$Insert
+        | BodyResponseCallback<Schema$Notification>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$Notification>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$Notification>
+        | BodyResponseCallback<Readable>
+    ): void | GaxiosPromise<Schema$Notification> | GaxiosPromise<Readable> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Notifications$Insert;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Notifications$Insert;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://storage.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl + '/storage/v1/b/{bucket}/notificationConfigs'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'POST',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['bucket'],
+        pathParams: ['bucket'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$Notification>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$Notification>(parameters);
+      }
+    }
+
+    /**
+     * Retrieves a list of notification subscriptions for a given bucket.
+     *
+     * @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$Notifications$List,
+      options: StreamMethodOptions
+    ): GaxiosPromise<Readable>;
+    list(
+      params?: Params$Resource$Notifications$List,
+      options?: MethodOptions
+    ): GaxiosPromise<Schema$Notifications>;
+    list(
+      params: Params$Resource$Notifications$List,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    list(
+      params: Params$Resource$Notifications$List,
+      options: MethodOptions | BodyResponseCallback<Schema$Notifications>,
+      callback: BodyResponseCallback<Schema$Notifications>
+    ): void;
+    list(
+      params: Params$Resource$Notifications$List,
+      callback: BodyResponseCallback<Schema$Notifications>
+    ): void;
+    list(callback: BodyResponseCallback<Schema$Notifications>): void;
+    list(
+      paramsOrCallback?:
+        | Params$Resource$Notifications$List
+        | BodyResponseCallback<Schema$Notifications>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$Notifications>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$Notifications>
+        | BodyResponseCallback<Readable>
+    ): void | GaxiosPromise<Schema$Notifications> | GaxiosPromise<Readable> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Notifications$List;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Notifications$List;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://storage.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl + '/storage/v1/b/{bucket}/notificationConfigs'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'GET',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['bucket'],
+        pathParams: ['bucket'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$Notifications>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$Notifications>(parameters);
+      }
+    }
+  }
+
+  export interface Params$Resource$Notifications$Delete
+    extends StandardParameters {
+    /**
+     * The parent bucket of the notification.
+     */
+    bucket?: string;
+    /**
+     * ID of the notification to delete.
+     */
+    notification?: string;
+    /**
+     * The project to be billed for this request. Required for Requester Pays buckets.
+     */
+    userProject?: string;
+  }
+  export interface Params$Resource$Notifications$Get
+    extends StandardParameters {
+    /**
+     * The parent bucket of the notification.
+     */
+    bucket?: string;
+    /**
+     * Notification ID
+     */
+    notification?: string;
+    /**
      * The project to be billed for this request. Required for Requester Pays buckets.
      */
     userProject?: string;
@@ -4514,6 +5437,100 @@ export namespace storage_v1 {
       this.context = context;
     }
 
+    /**
+     * Initiates a long-running bulk restore operation on the specified bucket.
+     *
+     * @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.
+     */
+    bulkRestore(
+      params: Params$Resource$Objects$Bulkrestore,
+      options: StreamMethodOptions
+    ): GaxiosPromise<Readable>;
+    bulkRestore(
+      params?: Params$Resource$Objects$Bulkrestore,
+      options?: MethodOptions
+    ): GaxiosPromise<Schema$GoogleLongrunningOperation>;
+    bulkRestore(
+      params: Params$Resource$Objects$Bulkrestore,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    bulkRestore(
+      params: Params$Resource$Objects$Bulkrestore,
+      options:
+        | MethodOptions
+        | BodyResponseCallback<Schema$GoogleLongrunningOperation>,
+      callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>
+    ): void;
+    bulkRestore(
+      params: Params$Resource$Objects$Bulkrestore,
+      callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>
+    ): void;
+    bulkRestore(
+      callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>
+    ): void;
+    bulkRestore(
+      paramsOrCallback?:
+        | Params$Resource$Objects$Bulkrestore
+        | BodyResponseCallback<Schema$GoogleLongrunningOperation>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$GoogleLongrunningOperation>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$GoogleLongrunningOperation>
+        | BodyResponseCallback<Readable>
+    ):
+      | void
+      | GaxiosPromise<Schema$GoogleLongrunningOperation>
+      | GaxiosPromise<Readable> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Objects$Bulkrestore;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Objects$Bulkrestore;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://storage.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (rootUrl + '/storage/v1/b/{bucket}/o/bulkRestore').replace(
+              /([^:]\/)\/+/g,
+              '$1'
+            ),
+            method: 'POST',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['bucket'],
+        pathParams: ['bucket'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$GoogleLongrunningOperation>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$GoogleLongrunningOperation>(parameters);
+      }
+    }
+
     /**
      * Concatenates a list of existing objects into a new object in the same bucket.
      *
@@ -5215,6 +6232,91 @@ export namespace storage_v1 {
       }
     }
 
+    /**
+     * Restores a soft-deleted object.
+     *
+     * @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.
+     */
+    restore(
+      params: Params$Resource$Objects$Restore,
+      options: StreamMethodOptions
+    ): GaxiosPromise<Readable>;
+    restore(
+      params?: Params$Resource$Objects$Restore,
+      options?: MethodOptions
+    ): GaxiosPromise<Schema$Object>;
+    restore(
+      params: Params$Resource$Objects$Restore,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    restore(
+      params: Params$Resource$Objects$Restore,
+      options: MethodOptions | BodyResponseCallback<Schema$Object>,
+      callback: BodyResponseCallback<Schema$Object>
+    ): void;
+    restore(
+      params: Params$Resource$Objects$Restore,
+      callback: BodyResponseCallback<Schema$Object>
+    ): void;
+    restore(callback: BodyResponseCallback<Schema$Object>): void;
+    restore(
+      paramsOrCallback?:
+        | Params$Resource$Objects$Restore
+        | BodyResponseCallback<Schema$Object>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$Object>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$Object>
+        | BodyResponseCallback<Readable>
+    ): void | GaxiosPromise<Schema$Object> | GaxiosPromise<Readable> {
+      let params = (paramsOrCallback || {}) as Params$Resource$Objects$Restore;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Objects$Restore;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://storage.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl + '/storage/v1/b/{bucket}/o/{object}/restore'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'POST',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['bucket', 'object'],
+        pathParams: ['bucket', 'object'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$Object>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$Object>(parameters);
+      }
+    }
+
     /**
      * Rewrites a source object to a destination object. Optionally overrides metadata.
      *
@@ -5664,6 +6766,18 @@ export namespace storage_v1 {
     }
   }
 
+  export interface Params$Resource$Objects$Bulkrestore
+    extends StandardParameters {
+    /**
+     * Name of the bucket in which the object resides.
+     */
+    bucket?: string;
+
+    /**
+     * Request body metadata
+     */
+    requestBody?: Schema$BulkRestoreObjectsRequest;
+  }
   export interface Params$Resource$Objects$Compose extends StandardParameters {
     /**
      * Name of the bucket containing the source objects. The destination object is stored in this bucket.
@@ -5841,6 +6955,10 @@ export namespace storage_v1 {
      * Set of properties to return. Defaults to noAcl.
      */
     projection?: string;
+    /**
+     * If true, only soft-deleted object versions will be listed. The default is false. For more information, see Soft Delete.
+     */
+    softDeleted?: boolean;
     /**
      * The project to be billed for this request. Required for Requester Pays buckets.
      */
@@ -5944,6 +7062,10 @@ export namespace storage_v1 {
      * 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;
+    /**
+     * Only applicable if delimiter is set to '/'. If true, will also include folders and managed folders (besides objects) in the returned prefixes.
+     */
+    includeFoldersAsPrefixes?: boolean;
     /**
      * If true, objects that end in exactly one instance of delimiter will have their metadata included in items in addition to prefixes.
      */
@@ -5968,6 +7090,10 @@ export namespace storage_v1 {
      * Set of properties to return. Defaults to noAcl.
      */
     projection?: string;
+    /**
+     * If true, only soft-deleted object versions will be listed. The default is false. For more information, see Soft Delete.
+     */
+    softDeleted?: boolean;
     /**
      * 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).
      */
@@ -5981,45 +7107,96 @@ export namespace storage_v1 {
      */
     versions?: boolean;
   }
-  export interface Params$Resource$Objects$Patch extends StandardParameters {
+  export interface Params$Resource$Objects$Patch extends StandardParameters {
+    /**
+     * Name of the bucket in which the object resides.
+     */
+    bucket?: string;
+    /**
+     * If present, selects a specific revision of this object (as opposed to the latest version, the default).
+     */
+    generation?: string;
+    /**
+     * Makes the operation conditional on whether the object's current generation matches the given value. Setting to 0 makes the operation succeed only if there are no live versions of the object.
+     */
+    ifGenerationMatch?: string;
+    /**
+     * Makes the operation conditional on whether the object's current generation does not match the given value. If no live object exists, the precondition fails. Setting to 0 makes the operation succeed only if there is a live version of the object.
+     */
+    ifGenerationNotMatch?: string;
+    /**
+     * Makes the operation conditional on whether the object's current metageneration matches the given value.
+     */
+    ifMetagenerationMatch?: string;
+    /**
+     * Makes the operation conditional on whether the object's current metageneration does not match the given value.
+     */
+    ifMetagenerationNotMatch?: string;
+    /**
+     * Name of the object. For information about how to URL encode object names to be path safe, see [Encoding URI Path Parts](https://cloud.google.com/storage/docs/request-endpoints#encoding).
+     */
+    object?: string;
+    /**
+     * Must be true to remove the retention configuration, reduce its unlocked retention period, or change its mode from unlocked to locked.
+     */
+    overrideUnlockedRetention?: boolean;
+    /**
+     * Apply a predefined set of access controls to this object.
+     */
+    predefinedAcl?: string;
+    /**
+     * Set of properties to return. Defaults to full.
+     */
+    projection?: string;
+    /**
+     * The project to be billed for this request, for Requester Pays buckets.
+     */
+    userProject?: string;
+
+    /**
+     * Request body metadata
+     */
+    requestBody?: Schema$Object;
+  }
+  export interface Params$Resource$Objects$Restore extends StandardParameters {
     /**
      * Name of the bucket in which the object resides.
      */
     bucket?: string;
     /**
-     * If present, selects a specific revision of this object (as opposed to the latest version, the default).
+     * If true, copies the source object's ACL; otherwise, uses the bucket's default object ACL. The default is false.
+     */
+    copySourceAcl?: boolean;
+    /**
+     * Selects a specific revision of this object.
      */
     generation?: string;
     /**
-     * Makes the operation conditional on whether the object's current generation matches the given value. Setting to 0 makes the operation succeed only if there are no live versions of the object.
+     * Makes the operation conditional on whether the object's one live generation matches the given value. Setting to 0 makes the operation succeed only if there are no live versions of the object.
      */
     ifGenerationMatch?: string;
     /**
-     * Makes the operation conditional on whether the object's current generation does not match the given value. If no live object exists, the precondition fails. Setting to 0 makes the operation succeed only if there is a live version of the object.
+     * Makes the operation conditional on whether none of the object's live generations match the given value. If no live object exists, the precondition fails. Setting to 0 makes the operation succeed only if there is a live version of the object.
      */
     ifGenerationNotMatch?: string;
     /**
-     * Makes the operation conditional on whether the object's current metageneration matches the given value.
+     * Makes the operation conditional on whether the object's one live metageneration matches the given value.
      */
     ifMetagenerationMatch?: string;
     /**
-     * Makes the operation conditional on whether the object's current metageneration does not match the given value.
+     * Makes the operation conditional on whether none of the object's live metagenerations match the given value.
      */
     ifMetagenerationNotMatch?: string;
     /**
-     * Name of the object. For information about how to URL encode object names to be path safe, see [Encoding URI Path Parts](https://cloud.google.com/storage/docs/request-endpoints#encoding).
+     * Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.
      */
     object?: string;
-    /**
-     * Apply a predefined set of access controls to this object.
-     */
-    predefinedAcl?: string;
     /**
      * Set of properties to return. Defaults to full.
      */
     projection?: string;
     /**
-     * The project to be billed for this request, for Requester Pays buckets.
+     * The project to be billed for this request. Required for Requester Pays buckets.
      */
     userProject?: string;
 
@@ -6187,6 +7364,10 @@ export namespace storage_v1 {
      * Name of the object. For information about how to URL encode object names to be path safe, see [Encoding URI Path Parts](https://cloud.google.com/storage/docs/request-endpoints#encoding).
      */
     object?: string;
+    /**
+     * Must be true to remove the retention configuration, reduce its unlocked retention period, or change its mode from unlocked to locked.
+     */
+    overrideUnlockedRetention?: boolean;
     /**
      * Apply a predefined set of access controls to this object.
      */
@@ -6257,6 +7438,324 @@ export namespace storage_v1 {
     requestBody?: Schema$Channel;
   }
 
+  export class Resource$Operations {
+    context: APIRequestContext;
+    constructor(context: APIRequestContext) {
+      this.context = context;
+    }
+
+    /**
+     * Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed.
+     *
+     * @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<void>;
+    cancel(
+      params: Params$Resource$Operations$Cancel,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    cancel(
+      params: Params$Resource$Operations$Cancel,
+      options: MethodOptions | BodyResponseCallback<void>,
+      callback: BodyResponseCallback<void>
+    ): void;
+    cancel(
+      params: Params$Resource$Operations$Cancel,
+      callback: BodyResponseCallback<void>
+    ): void;
+    cancel(callback: BodyResponseCallback<void>): void;
+    cancel(
+      paramsOrCallback?:
+        | Params$Resource$Operations$Cancel
+        | BodyResponseCallback<void>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<void>
+        | BodyResponseCallback<Readable>,
+      callback?: BodyResponseCallback<void> | BodyResponseCallback<Readable>
+    ): void | GaxiosPromise<void> | GaxiosPromise<Readable> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Operations$Cancel;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Operations$Cancel;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://storage.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl + '/storage/v1/b/{bucket}/operations/{operationId}/cancel'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'POST',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['bucket', 'operationId'],
+        pathParams: ['bucket', 'operationId'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<void>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<void>(parameters);
+      }
+    }
+
+    /**
+     * Gets the latest state of a long-running operation.
+     *
+     * @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$GoogleLongrunningOperation>;
+    get(
+      params: Params$Resource$Operations$Get,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    get(
+      params: Params$Resource$Operations$Get,
+      options:
+        | MethodOptions
+        | BodyResponseCallback<Schema$GoogleLongrunningOperation>,
+      callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>
+    ): void;
+    get(
+      params: Params$Resource$Operations$Get,
+      callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>
+    ): void;
+    get(
+      callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>
+    ): void;
+    get(
+      paramsOrCallback?:
+        | Params$Resource$Operations$Get
+        | BodyResponseCallback<Schema$GoogleLongrunningOperation>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$GoogleLongrunningOperation>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$GoogleLongrunningOperation>
+        | BodyResponseCallback<Readable>
+    ):
+      | void
+      | GaxiosPromise<Schema$GoogleLongrunningOperation>
+      | GaxiosPromise<Readable> {
+      let params = (paramsOrCallback || {}) as Params$Resource$Operations$Get;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Operations$Get;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://storage.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl + '/storage/v1/b/{bucket}/operations/{operationId}'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'GET',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['bucket', 'operationId'],
+        pathParams: ['bucket', 'operationId'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$GoogleLongrunningOperation>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$GoogleLongrunningOperation>(parameters);
+      }
+    }
+
+    /**
+     * Lists operations that match the specified filter in the request.
+     *
+     * @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$GoogleLongrunningListOperationsResponse>;
+    list(
+      params: Params$Resource$Operations$List,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    list(
+      params: Params$Resource$Operations$List,
+      options:
+        | MethodOptions
+        | BodyResponseCallback<Schema$GoogleLongrunningListOperationsResponse>,
+      callback: BodyResponseCallback<Schema$GoogleLongrunningListOperationsResponse>
+    ): void;
+    list(
+      params: Params$Resource$Operations$List,
+      callback: BodyResponseCallback<Schema$GoogleLongrunningListOperationsResponse>
+    ): void;
+    list(
+      callback: BodyResponseCallback<Schema$GoogleLongrunningListOperationsResponse>
+    ): void;
+    list(
+      paramsOrCallback?:
+        | Params$Resource$Operations$List
+        | BodyResponseCallback<Schema$GoogleLongrunningListOperationsResponse>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$GoogleLongrunningListOperationsResponse>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$GoogleLongrunningListOperationsResponse>
+        | BodyResponseCallback<Readable>
+    ):
+      | void
+      | GaxiosPromise<Schema$GoogleLongrunningListOperationsResponse>
+      | GaxiosPromise<Readable> {
+      let params = (paramsOrCallback || {}) as Params$Resource$Operations$List;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Operations$List;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://storage.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (rootUrl + '/storage/v1/b/{bucket}/operations').replace(
+              /([^:]\/)\/+/g,
+              '$1'
+            ),
+            method: 'GET',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['bucket'],
+        pathParams: ['bucket'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$GoogleLongrunningListOperationsResponse>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$GoogleLongrunningListOperationsResponse>(
+          parameters
+        );
+      }
+    }
+  }
+
+  export interface Params$Resource$Operations$Cancel
+    extends StandardParameters {
+    /**
+     * The parent bucket of the operation resource.
+     */
+    bucket?: string;
+    /**
+     * The ID of the operation resource.
+     */
+    operationId?: string;
+  }
+  export interface Params$Resource$Operations$Get extends StandardParameters {
+    /**
+     * The parent bucket of the operation resource.
+     */
+    bucket?: string;
+    /**
+     * The ID of the operation resource.
+     */
+    operationId?: string;
+  }
+  export interface Params$Resource$Operations$List extends StandardParameters {
+    /**
+     * Name of the bucket in which to look for operations.
+     */
+    bucket?: string;
+    /**
+     * A filter to narrow down results to a preferred subset. The filtering language is documented in more detail in [AIP-160](https://google.aip.dev/160).
+     */
+    filter?: string;
+    /**
+     * Maximum number of items to return in a single page of responses. Fewer total results may be returned than requested. The service uses this parameter or 100 items, whichever is smaller.
+     */
+    pageSize?: number;
+    /**
+     * A previously-returned page token representing part of the larger set of results to view.
+     */
+    pageToken?: string;
+  }
+
   export class Resource$Projects {
     context: APIRequestContext;
     hmacKeys: Resource$Projects$Hmackeys;