@google-cloud/storage

  • Version 7.16.0
  • Published
  • 1.7 MB
  • 15 dependencies
  • Apache-2.0 license

Install

npm i @google-cloud/storage
yarn add @google-cloud/storage
pnpm add @google-cloud/storage

Overview

Cloud Storage Client Library for Node.js

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Variables

variable CRC32C_DEFAULT_VALIDATOR_GENERATOR

const CRC32C_DEFAULT_VALIDATOR_GENERATOR: CRC32CValidatorGenerator;

    variable CRC32C_EXCEPTION_MESSAGES

    const CRC32C_EXCEPTION_MESSAGES: {
    readonly INVALID_INIT_BASE64_RANGE: (l: number) => string;
    readonly INVALID_INIT_BUFFER_LENGTH: (l: number) => string;
    readonly INVALID_INIT_INTEGER: (l: number) => string;
    };

      variable CRC32C_EXTENSION_TABLE

      const CRC32C_EXTENSION_TABLE: any;

        variable CRC32C_EXTENSIONS

        const CRC32C_EXTENSIONS: readonly [
        0,
        4067132163,
        3778769143,
        324072436,
        3348797215,
        904991772,
        648144872,
        3570033899,
        2329499855,
        2024987596,
        1809983544,
        2575936315,
        1296289744,
        3207089363,
        2893594407,
        1578318884,
        274646895,
        3795141740,
        4049975192,
        51262619,
        3619967088,
        632279923,
        922689671,
        3298075524,
        2592579488,
        1760304291,
        2075979607,
        2312596564,
        1562183871,
        2943781820,
        3156637768,
        1313733451,
        549293790,
        3537243613,
        3246849577,
        871202090,
        3878099393,
        357341890,
        102525238,
        4101499445,
        2858735121,
        1477399826,
        1264559846,
        3107202533,
        1845379342,
        2677391885,
        2361733625,
        2125378298,
        820201905,
        3263744690,
        3520608582,
        598981189,
        4151959214,
        85089709,
        373468761,
        3827903834,
        3124367742,
        1213305469,
        1526817161,
        2842354314,
        2107672161,
        2412447074,
        2627466902,
        1861252501,
        1098587580,
        3004210879,
        2688576843,
        1378610760,
        2262928035,
        1955203488,
        1742404180,
        2511436119,
        3416409459,
        969524848,
        714683780,
        3639785095,
        205050476,
        4266873199,
        3976438427,
        526918040,
        1361435347,
        2739821008,
        2954799652,
        1114974503,
        2529119692,
        1691668175,
        2005155131,
        2247081528,
        3690758684,
        697762079,
        986182379,
        3366744552,
        476452099,
        3993867776,
        4250756596,
        255256311,
        1640403810,
        2477592673,
        2164122517,
        1922457750,
        2791048317,
        1412925310,
        1197962378,
        3037525897,
        3944729517,
        427051182,
        170179418,
        4165941337,
        746937522,
        3740196785,
        3451792453,
        1070968646,
        1905808397,
        2213795598,
        2426610938,
        1657317369,
        3053634322,
        1147748369,
        1463399397,
        2773627110,
        4215344322,
        153784257,
        444234805,
        3893493558,
        1021025245,
        3467647198,
        3722505002,
        797665321,
        2197175160,
        1889384571,
        1674398607,
        2443626636,
        1164749927,
        3070701412,
        2757221520,
        1446797203,
        137323447,
        4198817972,
        3910406976,
        461344835,
        3484808360,
        1037989803,
        781091935,
        3705997148,
        2460548119,
        1623424788,
        1939049696,
        2180517859,
        1429367560,
        2807687179,
        3020495871,
        1180866812,
        410100952,
        3927582683,
        4182430767,
        186734380,
        3756733383,
        763408580,
        1053836080,
        3434856499,
        2722870694,
        1344288421,
        1131464017,
        2971354706,
        1708204729,
        2545590714,
        2229949006,
        1988219213,
        680717673,
        3673779818,
        3383336350,
        1002577565,
        4010310262,
        493091189,
        238226049,
        4233660802,
        2987750089,
        1082061258,
        1395524158,
        2705686845,
        1972364758,
        2279892693,
        2494862625,
        1725896226,
        952904198,
        3399985413,
        3656866545,
        731699698,
        4283874585,
        222117402,
        510512622,
        3959836397,
        3280807620,
        837199303,
        582374963,
        3504198960,
        68661723,
        4135334616,
        3844915500,
        390545967,
        1230274059,
        3141532936,
        2825850620,
        1510247935,
        2395924756,
        2091215383,
        1878366691,
        2644384480,
        3553878443,
        565732008,
        854102364,
        3229815391,
        340358836,
        3861050807,
        4117890627,
        119113024,
        1493875044,
        2875275879,
        3090270611,
        1247431312,
        2660249211,
        1828433272,
        2141937292,
        2378227087,
        3811616794,
        291187481,
        34330861,
        4032846830,
        615137029,
        3603020806,
        3314634738,
        939183345,
        1776939221,
        2609017814,
        2295496738,
        2058945313,
        2926798794,
        1545135305,
        1330124605,
        3173225534,
        4084100981,
        17165430,
        307568514,
        3762199681,
        888469610,
        3332340585,
        3587147933,
        665062302,
        2042050490,
        2346497209,
        2559330125,
        1793573966,
        3190661285,
        1279665062,
        1595330642,
        2910671697
        ];
        • Ported from

        Functions

        function RETRYABLE_ERR_FN_DEFAULT

        RETRYABLE_ERR_FN_DEFAULT: (err?: ApiError) => boolean;
        • Returns true if the API request should be retried, given the error that was given the first time the request was attempted.

          Parameter err

          The API error to check if it is appropriate to retry. {boolean} True if the API request should be retried, false otherwise.

        Classes

        class ApiError

        class ApiError extends Error {}
        • Custom error type for API errors.

          Parameter errorBody

          Error object.

        constructor

        constructor(errorMessage: string);

          constructor

          constructor(errorBody: GoogleErrorBody);

            property code

            code?: number;

              property errors

              errors?: GoogleInnerError[];

                property response

                response?: r.Response;

                  method createMultiErrorMessage

                  static createMultiErrorMessage: (
                  err: GoogleErrorBody,
                  errors?: GoogleInnerError[]
                  ) => string;
                  • Pieces together an error message by combining all unique error messages returned from a single GoogleError

                    Parameter err

                    The original error.

                    Parameter errors

                    Inner errors, if any.

                    Returns

                    {string}

                  class Bucket

                  class Bucket extends ServiceObject<Bucket, BucketMetadata> {}
                  • Create a Bucket object to interact with a Cloud Storage bucket.

                    Parameter storage

                    A Storage instance.

                    Parameter name

                    The name of the bucket.

                    Parameter options

                    Configuration object.

                    Parameter

                    {string} [options.userProject] User project.

                    Example 1

                    const {Storage} = require('@google-cloud/storage');
                    const storage = new Storage();
                    const bucket = storage.bucket('albums');

                  constructor

                  constructor(storage: Storage, name: string, options?: BucketOptions);

                    property acl

                    acl: Acl;

                      property cloudStorageURI

                      readonly cloudStorageURI: URL;
                      • The bucket's Cloud Storage URI (gs://)

                        Example 1

                        const {Storage} = require('@google-cloud/storage');
                        const storage = new Storage();
                        const bucket = storage.bucket('my-bucket');
                        // `gs://my-bucket`
                        const href = bucket.cloudStorageURI.href;

                      property crc32cGenerator

                      crc32cGenerator: CRC32CValidatorGenerator;

                        property iam

                        iam: Iam;

                          property instancePreconditionOpts

                          instancePreconditionOpts?: PreconditionOptions;

                            property name

                            name: string;

                              property signer

                              signer?: URLSigner;

                                property storage

                                storage: Storage;
                                • A reference to the Storage associated with this Bucket instance. Bucket#storage {Storage}

                                property userProject

                                userProject?: string;
                                • A user project to apply to each request from this bucket. Bucket#userProject {string}

                                method addLifecycleRule

                                addLifecycleRule: {
                                (
                                rule: LifecycleRule | LifecycleRule[],
                                options?: AddLifecycleRuleOptions
                                ): Promise<SetBucketMetadataResponse>;
                                (
                                rule: LifecycleRule | LifecycleRule[],
                                options: AddLifecycleRuleOptions,
                                callback: SetBucketMetadataCallback
                                ): void;
                                (
                                rule: LifecycleRule | LifecycleRule[],
                                callback: SetBucketMetadataCallback
                                ): void;
                                };

                                  method combine

                                  combine: {
                                  (
                                  sources: string[] | File[],
                                  destination: string | File,
                                  options?: CombineOptions
                                  ): Promise<CombineResponse>;
                                  (
                                  sources: string[] | File[],
                                  destination: string | File,
                                  options: CombineOptions,
                                  callback: CombineCallback
                                  ): void;
                                  (
                                  sources: string[] | File[],
                                  destination: string | File,
                                  callback: CombineCallback
                                  ): void;
                                  };

                                    method createChannel

                                    createChannel: {
                                    (
                                    id: string,
                                    config: CreateChannelConfig,
                                    options?: CreateChannelOptions
                                    ): Promise<CreateChannelResponse>;
                                    (
                                    id: string,
                                    config: CreateChannelConfig,
                                    callback: CreateChannelCallback
                                    ): void;
                                    (
                                    id: string,
                                    config: CreateChannelConfig,
                                    options: CreateChannelOptions,
                                    callback: CreateChannelCallback
                                    ): void;
                                    };

                                      method createNotification

                                      createNotification: {
                                      (
                                      topic: string,
                                      options?: CreateNotificationOptions
                                      ): Promise<CreateNotificationResponse>;
                                      (
                                      topic: string,
                                      options: CreateNotificationOptions,
                                      callback: CreateNotificationCallback
                                      ): void;
                                      (topic: string, callback: CreateNotificationCallback): void;
                                      };

                                        method deleteFiles

                                        deleteFiles: {
                                        (query?: DeleteFilesOptions): Promise<void>;
                                        (callback: DeleteFilesCallback): void;
                                        (query: DeleteFilesOptions, callback: DeleteFilesCallback): void;
                                        };

                                          method deleteLabels

                                          deleteLabels: {
                                          (labels?: string | string[]): Promise<DeleteLabelsResponse>;
                                          (options: PreconditionOptions): Promise<DeleteLabelsResponse>;
                                          (callback: SetLabelsCallback): void;
                                          (
                                          labels: string | string[],
                                          options: PreconditionOptions
                                          ): Promise<DeleteLabelsResponse>;
                                          (labels: string | string[], callback: SetLabelsCallback): void;
                                          (
                                          labels: string | string[],
                                          options: PreconditionOptions,
                                          callback: SetLabelsCallback
                                          ): void;
                                          };

                                            method disableAutoRetryConditionallyIdempotent_

                                            disableAutoRetryConditionallyIdempotent_: (
                                            coreOpts: any,
                                            methodType: AvailableServiceObjectMethods,
                                            localPreconditionOptions?: PreconditionOptions
                                            ) => void;

                                              method disableRequesterPays

                                              disableRequesterPays: {
                                              (
                                              options?: DisableRequesterPaysOptions
                                              ): Promise<DisableRequesterPaysResponse>;
                                              (callback: DisableRequesterPaysCallback): void;
                                              (options: PreconditionOptions, callback: DisableRequesterPaysCallback): void;
                                              };

                                                method enableLogging

                                                enableLogging: {
                                                (config: EnableLoggingOptions): Promise<SetBucketMetadataResponse>;
                                                (config: EnableLoggingOptions, callback: SetBucketMetadataCallback): void;
                                                };

                                                  method enableRequesterPays

                                                  enableRequesterPays: {
                                                  (options?: EnableRequesterPaysOptions): Promise<EnableRequesterPaysResponse>;
                                                  (callback: EnableRequesterPaysCallback): void;
                                                  (options: PreconditionOptions, callback: EnableRequesterPaysCallback): void;
                                                  };

                                                    method file

                                                    file: (name: string, options?: FileOptions) => File;
                                                    • Create a File object. See File to see how to handle the different use cases you may have.

                                                      Parameter name

                                                      The name of the file in this bucket.

                                                      Parameter options

                                                      Configuration options.

                                                      Parameter

                                                      {string|number} [options.generation] Only use a specific revision of this file.

                                                      Parameter

                                                      {string} [options.encryptionKey] A custom encryption key. See Customer-supplied Encryption Keys.

                                                      Parameter

                                                      {string} [options.kmsKeyName] The name of the Cloud KMS key that will be used to encrypt the object. Must be in the format: projects/my-project/locations/location/keyRings/my-kr/cryptoKeys/my-key. KMS key ring must use the same location as the bucket.

                                                      Parameter

                                                      {string} [options.userProject] The ID of the project which will be billed for all requests made from File object.

                                                      Returns

                                                      {File}

                                                      Example 1

                                                      const {Storage} = require('@google-cloud/storage');
                                                      const storage = new Storage();
                                                      const bucket = storage.bucket('albums');
                                                      const file = bucket.file('my-existing-file.png');

                                                    method getFiles

                                                    getFiles: {
                                                    (query?: GetFilesOptions): Promise<GetFilesResponse>;
                                                    (query: GetFilesOptions, callback: GetFilesCallback): void;
                                                    (callback: GetFilesCallback): void;
                                                    };

                                                      method getFilesStream

                                                      getFilesStream: (query?: GetFilesOptions) => Readable;

                                                        method getId

                                                        getId: () => string;

                                                          method getLabels

                                                          getLabels: {
                                                          (options?: GetLabelsOptions): Promise<GetLabelsResponse>;
                                                          (callback: GetLabelsCallback): void;
                                                          (options: GetLabelsOptions, callback: GetLabelsCallback): void;
                                                          };

                                                            method getNotifications

                                                            getNotifications: {
                                                            (options?: GetNotificationsOptions): Promise<GetNotificationsResponse>;
                                                            (callback: GetNotificationsCallback): void;
                                                            (options: GetNotificationsOptions, callback: GetNotificationsCallback): void;
                                                            };

                                                              method getSignedUrl

                                                              getSignedUrl: {
                                                              (cfg: GetBucketSignedUrlConfig): Promise<GetSignedUrlResponse>;
                                                              (cfg: GetBucketSignedUrlConfig, callback: GetSignedUrlCallback): void;
                                                              };

                                                                method lock

                                                                lock: {
                                                                (metageneration: number | string): Promise<BucketLockResponse>;
                                                                (metageneration: string | number, callback: BucketLockCallback): void;
                                                                };

                                                                  method makeAllFilesPublicPrivate_

                                                                  makeAllFilesPublicPrivate_: {
                                                                  (
                                                                  options?: MakeAllFilesPublicPrivateOptions
                                                                  ): Promise<MakeAllFilesPublicPrivateResponse>;
                                                                  (callback: MakeAllFilesPublicPrivateCallback): void;
                                                                  (
                                                                  options: MakeAllFilesPublicPrivateOptions,
                                                                  callback: MakeAllFilesPublicPrivateCallback
                                                                  ): void;
                                                                  };

                                                                    method makePrivate

                                                                    makePrivate: {
                                                                    (options?: MakeBucketPrivateOptions): Promise<MakeBucketPrivateResponse>;
                                                                    (callback: MakeBucketPrivateCallback): void;
                                                                    (
                                                                    options: MakeBucketPrivateOptions,
                                                                    callback: MakeBucketPrivateCallback
                                                                    ): void;
                                                                    };

                                                                      method makePublic

                                                                      makePublic: {
                                                                      (options?: MakeBucketPublicOptions): Promise<MakeBucketPublicResponse>;
                                                                      (callback: MakeBucketPublicCallback): void;
                                                                      (options: MakeBucketPublicOptions, callback: MakeBucketPublicCallback): void;
                                                                      };

                                                                        method notification

                                                                        notification: (id: string) => Notification;
                                                                        • Get a reference to a Cloud Pub/Sub Notification.

                                                                          Parameter id

                                                                          ID of notification.

                                                                          Returns

                                                                          {Notification}

                                                                          Example 1

                                                                          const {Storage} = require('@google-cloud/storage');
                                                                          const storage = new Storage();
                                                                          const bucket = storage.bucket('my-bucket');
                                                                          const notification = bucket.notification('1');

                                                                          See Also

                                                                          • Notification

                                                                        method removeRetentionPeriod

                                                                        removeRetentionPeriod: {
                                                                        (options?: SetBucketMetadataOptions): Promise<SetBucketMetadataResponse>;
                                                                        (callback: SetBucketMetadataCallback): void;
                                                                        (
                                                                        options: SetBucketMetadataOptions,
                                                                        callback: SetBucketMetadataCallback
                                                                        ): void;
                                                                        };

                                                                          method request

                                                                          request: {
                                                                          (reqOpts: DecorateRequestOptions): Promise<RequestResponse>;
                                                                          (reqOpts: DecorateRequestOptions, callback: BodyResponseCallback): void;
                                                                          };

                                                                            method restore

                                                                            restore: (options: RestoreOptions) => Promise<Bucket>;
                                                                            • Restores a soft-deleted bucket

                                                                              Parameter options

                                                                              Restore options.

                                                                              Returns

                                                                              {Promise}

                                                                            method setCorsConfiguration

                                                                            setCorsConfiguration: {
                                                                            (
                                                                            corsConfiguration: Cors[],
                                                                            options?: SetBucketMetadataOptions
                                                                            ): Promise<SetBucketMetadataResponse>;
                                                                            (corsConfiguration: Cors[], callback: SetBucketMetadataCallback): void;
                                                                            (
                                                                            corsConfiguration: Cors[],
                                                                            options: SetBucketMetadataOptions,
                                                                            callback: SetBucketMetadataCallback
                                                                            ): void;
                                                                            };

                                                                              method setLabels

                                                                              setLabels: {
                                                                              (labels: Labels, options?: SetLabelsOptions): Promise<SetLabelsResponse>;
                                                                              (labels: Labels, callback: SetLabelsCallback): void;
                                                                              (
                                                                              labels: Labels,
                                                                              options: SetLabelsOptions,
                                                                              callback: SetLabelsCallback
                                                                              ): void;
                                                                              };

                                                                                method setMetadata

                                                                                setMetadata: {
                                                                                (metadata: BucketMetadata, options?: SetMetadataOptions): Promise<
                                                                                SetMetadataResponse<BucketMetadata>
                                                                                >;
                                                                                (metadata: BucketMetadata, callback: MetadataCallback<BucketMetadata>): void;
                                                                                (
                                                                                metadata: BucketMetadata,
                                                                                options: object,
                                                                                callback: MetadataCallback<BucketMetadata>
                                                                                ): void;
                                                                                };

                                                                                  method setRetentionPeriod

                                                                                  setRetentionPeriod: {
                                                                                  (
                                                                                  duration: number,
                                                                                  options?: SetBucketMetadataOptions
                                                                                  ): Promise<SetBucketMetadataResponse>;
                                                                                  (duration: number, callback: SetBucketMetadataCallback): void;
                                                                                  (
                                                                                  duration: number,
                                                                                  options: SetBucketMetadataOptions,
                                                                                  callback: SetBucketMetadataCallback
                                                                                  ): void;
                                                                                  };

                                                                                    method setStorageClass

                                                                                    setStorageClass: {
                                                                                    (
                                                                                    storageClass: string,
                                                                                    options?: SetBucketStorageClassOptions
                                                                                    ): Promise<SetBucketMetadataResponse>;
                                                                                    (storageClass: string, callback: SetBucketStorageClassCallback): void;
                                                                                    (
                                                                                    storageClass: string,
                                                                                    options: SetBucketStorageClassOptions,
                                                                                    callback: SetBucketStorageClassCallback
                                                                                    ): void;
                                                                                    };

                                                                                      method setUserProject

                                                                                      setUserProject: (userProject: string) => void;
                                                                                      • Set a user project to be billed for all requests made from this Bucket object and any files referenced from this Bucket object.

                                                                                        Parameter userProject

                                                                                        The user project.

                                                                                        Example 1

                                                                                        const {Storage} = require('@google-cloud/storage');
                                                                                        const storage = new Storage();
                                                                                        const bucket = storage.bucket('albums');
                                                                                        bucket.setUserProject('grape-spaceship-123');

                                                                                      method upload

                                                                                      upload: {
                                                                                      (pathString: string, options?: UploadOptions): Promise<UploadResponse>;
                                                                                      (pathString: string, options: UploadOptions, callback: UploadCallback): void;
                                                                                      (pathString: string, callback: UploadCallback): void;
                                                                                      };

                                                                                        class Channel

                                                                                        class Channel extends ServiceObject<Channel, BaseMetadata> {}
                                                                                        • Create a channel object to interact with a Cloud Storage channel.

                                                                                          See Object Change Notification

                                                                                          Parameter id

                                                                                          The ID of the channel.

                                                                                          Parameter resourceId

                                                                                          The resource ID of the channel.

                                                                                          Example 1

                                                                                          const {Storage} = require('@google-cloud/storage');
                                                                                          const storage = new Storage();
                                                                                          const channel = storage.channel('id', 'resource-id');

                                                                                        constructor

                                                                                        constructor(storage: Storage, id: string, resourceId: string);

                                                                                          method stop

                                                                                          stop: { (): Promise<unknown>; (callback: StopCallback): void };

                                                                                            class CRC32C

                                                                                            class CRC32C implements CRC32CValidator {}

                                                                                              constructor

                                                                                              constructor(initialValue?: number);
                                                                                              • Constructs a new CRC32C object.

                                                                                                Reconstruction is recommended via the CRC32C.from static method.

                                                                                                Parameter initialValue

                                                                                                An initial CRC32C value - a signed 32-bit integer.

                                                                                              property CRC32C_EXTENSION_TABLE

                                                                                              static readonly CRC32C_EXTENSION_TABLE: any;

                                                                                                property CRC32C_EXTENSIONS

                                                                                                static readonly CRC32C_EXTENSIONS: readonly [
                                                                                                0,
                                                                                                4067132163,
                                                                                                3778769143,
                                                                                                324072436,
                                                                                                3348797215,
                                                                                                904991772,
                                                                                                648144872,
                                                                                                3570033899,
                                                                                                2329499855,
                                                                                                2024987596,
                                                                                                1809983544,
                                                                                                2575936315,
                                                                                                1296289744,
                                                                                                3207089363,
                                                                                                2893594407,
                                                                                                1578318884,
                                                                                                274646895,
                                                                                                3795141740,
                                                                                                4049975192,
                                                                                                51262619,
                                                                                                3619967088,
                                                                                                632279923,
                                                                                                922689671,
                                                                                                3298075524,
                                                                                                2592579488,
                                                                                                1760304291,
                                                                                                2075979607,
                                                                                                2312596564,
                                                                                                1562183871,
                                                                                                2943781820,
                                                                                                3156637768,
                                                                                                1313733451,
                                                                                                549293790,
                                                                                                3537243613,
                                                                                                3246849577,
                                                                                                871202090,
                                                                                                3878099393,
                                                                                                357341890,
                                                                                                102525238,
                                                                                                4101499445,
                                                                                                2858735121,
                                                                                                1477399826,
                                                                                                1264559846,
                                                                                                3107202533,
                                                                                                1845379342,
                                                                                                2677391885,
                                                                                                2361733625,
                                                                                                2125378298,
                                                                                                820201905,
                                                                                                3263744690,
                                                                                                3520608582,
                                                                                                598981189,
                                                                                                4151959214,
                                                                                                85089709,
                                                                                                373468761,
                                                                                                3827903834,
                                                                                                3124367742,
                                                                                                1213305469,
                                                                                                1526817161,
                                                                                                2842354314,
                                                                                                2107672161,
                                                                                                2412447074,
                                                                                                2627466902,
                                                                                                1861252501,
                                                                                                1098587580,
                                                                                                3004210879,
                                                                                                2688576843,
                                                                                                1378610760,
                                                                                                2262928035,
                                                                                                1955203488,
                                                                                                1742404180,
                                                                                                2511436119,
                                                                                                3416409459,
                                                                                                969524848,
                                                                                                714683780,
                                                                                                3639785095,
                                                                                                205050476,
                                                                                                4266873199,
                                                                                                3976438427,
                                                                                                526918040,
                                                                                                1361435347,
                                                                                                2739821008,
                                                                                                2954799652,
                                                                                                1114974503,
                                                                                                2529119692,
                                                                                                1691668175,
                                                                                                2005155131,
                                                                                                2247081528,
                                                                                                3690758684,
                                                                                                697762079,
                                                                                                986182379,
                                                                                                3366744552,
                                                                                                476452099,
                                                                                                3993867776,
                                                                                                4250756596,
                                                                                                255256311,
                                                                                                1640403810,
                                                                                                2477592673,
                                                                                                2164122517,
                                                                                                1922457750,
                                                                                                2791048317,
                                                                                                1412925310,
                                                                                                1197962378,
                                                                                                3037525897,
                                                                                                3944729517,
                                                                                                427051182,
                                                                                                170179418,
                                                                                                4165941337,
                                                                                                746937522,
                                                                                                3740196785,
                                                                                                3451792453,
                                                                                                1070968646,
                                                                                                1905808397,
                                                                                                2213795598,
                                                                                                2426610938,
                                                                                                1657317369,
                                                                                                3053634322,
                                                                                                1147748369,
                                                                                                1463399397,
                                                                                                2773627110,
                                                                                                4215344322,
                                                                                                153784257,
                                                                                                444234805,
                                                                                                3893493558,
                                                                                                1021025245,
                                                                                                3467647198,
                                                                                                3722505002,
                                                                                                797665321,
                                                                                                2197175160,
                                                                                                1889384571,
                                                                                                1674398607,
                                                                                                2443626636,
                                                                                                1164749927,
                                                                                                3070701412,
                                                                                                2757221520,
                                                                                                1446797203,
                                                                                                137323447,
                                                                                                4198817972,
                                                                                                3910406976,
                                                                                                461344835,
                                                                                                3484808360,
                                                                                                1037989803,
                                                                                                781091935,
                                                                                                3705997148,
                                                                                                2460548119,
                                                                                                1623424788,
                                                                                                1939049696,
                                                                                                2180517859,
                                                                                                1429367560,
                                                                                                2807687179,
                                                                                                3020495871,
                                                                                                1180866812,
                                                                                                410100952,
                                                                                                3927582683,
                                                                                                4182430767,
                                                                                                186734380,
                                                                                                3756733383,
                                                                                                763408580,
                                                                                                1053836080,
                                                                                                3434856499,
                                                                                                2722870694,
                                                                                                1344288421,
                                                                                                1131464017,
                                                                                                2971354706,
                                                                                                1708204729,
                                                                                                2545590714,
                                                                                                2229949006,
                                                                                                1988219213,
                                                                                                680717673,
                                                                                                3673779818,
                                                                                                3383336350,
                                                                                                1002577565,
                                                                                                4010310262,
                                                                                                493091189,
                                                                                                238226049,
                                                                                                4233660802,
                                                                                                2987750089,
                                                                                                1082061258,
                                                                                                1395524158,
                                                                                                2705686845,
                                                                                                1972364758,
                                                                                                2279892693,
                                                                                                2494862625,
                                                                                                1725896226,
                                                                                                952904198,
                                                                                                3399985413,
                                                                                                3656866545,
                                                                                                731699698,
                                                                                                4283874585,
                                                                                                222117402,
                                                                                                510512622,
                                                                                                3959836397,
                                                                                                3280807620,
                                                                                                837199303,
                                                                                                582374963,
                                                                                                3504198960,
                                                                                                68661723,
                                                                                                4135334616,
                                                                                                3844915500,
                                                                                                390545967,
                                                                                                1230274059,
                                                                                                3141532936,
                                                                                                2825850620,
                                                                                                1510247935,
                                                                                                2395924756,
                                                                                                2091215383,
                                                                                                1878366691,
                                                                                                2644384480,
                                                                                                3553878443,
                                                                                                565732008,
                                                                                                854102364,
                                                                                                3229815391,
                                                                                                340358836,
                                                                                                3861050807,
                                                                                                4117890627,
                                                                                                119113024,
                                                                                                1493875044,
                                                                                                2875275879,
                                                                                                3090270611,
                                                                                                1247431312,
                                                                                                2660249211,
                                                                                                1828433272,
                                                                                                2141937292,
                                                                                                2378227087,
                                                                                                3811616794,
                                                                                                291187481,
                                                                                                34330861,
                                                                                                4032846830,
                                                                                                615137029,
                                                                                                3603020806,
                                                                                                3314634738,
                                                                                                939183345,
                                                                                                1776939221,
                                                                                                2609017814,
                                                                                                2295496738,
                                                                                                2058945313,
                                                                                                2926798794,
                                                                                                1545135305,
                                                                                                1330124605,
                                                                                                3173225534,
                                                                                                4084100981,
                                                                                                17165430,
                                                                                                307568514,
                                                                                                3762199681,
                                                                                                888469610,
                                                                                                3332340585,
                                                                                                3587147933,
                                                                                                665062302,
                                                                                                2042050490,
                                                                                                2346497209,
                                                                                                2559330125,
                                                                                                1793573966,
                                                                                                3190661285,
                                                                                                1279665062,
                                                                                                1595330642,
                                                                                                2910671697
                                                                                                ];

                                                                                                  method from

                                                                                                  static from: (
                                                                                                  value: ArrayBuffer | ArrayBufferView | CRC32CValidator | string | number
                                                                                                  ) => CRC32C;
                                                                                                  • Generates a CRC32C from a variety of compatable types. Note: strings are treated as input, not as file paths to read from.

                                                                                                    Parameter value

                                                                                                    A number, 4-byte ArrayBufferView/Buffer/TypedArray, or 4-byte base64-encoded data (string)

                                                                                                  method fromFile

                                                                                                  static fromFile: (file: PathLike) => Promise<CRC32C>;

                                                                                                    method toBuffer

                                                                                                    toBuffer: () => Buffer;
                                                                                                    • Returns a Buffer representation of the CRC32C value

                                                                                                    method toJSON

                                                                                                    toJSON: () => string;
                                                                                                    • Returns a JSON-compatible, base64-encoded representation of the CRC32C value.

                                                                                                      See

                                                                                                    method toString

                                                                                                    toString: () => string;
                                                                                                    • Returns a base64-encoded representation of the CRC32C value.

                                                                                                      See

                                                                                                    method update

                                                                                                    update: (data: Buffer) => void;
                                                                                                    • Calculates a CRC32C from a provided buffer.

                                                                                                      Implementation inspired from: - - -

                                                                                                      Parameter data

                                                                                                      The Buffer to generate the CRC32C from

                                                                                                    method validate

                                                                                                    validate: (input: Buffer | CRC32CValidator | string | number) => boolean;
                                                                                                    • Validates a provided input to the current CRC32C value.

                                                                                                      Parameter input

                                                                                                      A Buffer, CRC32C-compatible object, base64-encoded data (string), or signed 32-bit integer

                                                                                                    method valueOf

                                                                                                    valueOf: () => number;
                                                                                                    • Returns the number representation of the CRC32C value as a signed 32-bit integer

                                                                                                      See

                                                                                                    class File

                                                                                                    class File extends ServiceObject<File, FileMetadata> {}

                                                                                                    constructor

                                                                                                    constructor(bucket: Bucket, name: string, options?: FileOptions);
                                                                                                    • Constructs a file object.

                                                                                                      Parameter bucket

                                                                                                      The Bucket instance this file is attached to.

                                                                                                      Parameter name

                                                                                                      The name of the remote file.

                                                                                                      Parameter options

                                                                                                      Configuration options.

                                                                                                      Example 1

                                                                                                      const {Storage} = require('@google-cloud/storage');
                                                                                                      const storage = new Storage();
                                                                                                      const myBucket = storage.bucket('my-bucket');
                                                                                                      const file = myBucket.file('my-file');

                                                                                                    property acl

                                                                                                    acl: Acl;

                                                                                                      property bucket

                                                                                                      bucket: Bucket;

                                                                                                        property cloudStorageURI

                                                                                                        readonly cloudStorageURI: URL;
                                                                                                        • The object's Cloud Storage URI (gs://)

                                                                                                          Example 1

                                                                                                          const {Storage} = require('@google-cloud/storage');
                                                                                                          const storage = new Storage();
                                                                                                          const bucket = storage.bucket('my-bucket');
                                                                                                          const file = bucket.file('image.png');
                                                                                                          // `gs://my-bucket/image.png`
                                                                                                          const href = file.cloudStorageURI.href;

                                                                                                        property crc32cGenerator

                                                                                                        crc32cGenerator: CRC32CValidatorGenerator;

                                                                                                          property generation

                                                                                                          generation?: number;

                                                                                                            property instancePreconditionOpts

                                                                                                            instancePreconditionOpts?: PreconditionOptions;

                                                                                                              property kmsKeyName

                                                                                                              kmsKeyName?: string;

                                                                                                                property name

                                                                                                                name: string;

                                                                                                                  property parent

                                                                                                                  parent: Bucket;

                                                                                                                    property restoreToken

                                                                                                                    restoreToken?: string;

                                                                                                                      property signer

                                                                                                                      signer?: URLSigner;

                                                                                                                        property storage

                                                                                                                        storage: Storage;

                                                                                                                          property userProject

                                                                                                                          userProject?: string;

                                                                                                                            method copy

                                                                                                                            copy: {
                                                                                                                            (
                                                                                                                            destination: string | Bucket | File,
                                                                                                                            options?: CopyOptions
                                                                                                                            ): Promise<CopyResponse>;
                                                                                                                            (destination: string | Bucket | File, callback: CopyCallback): void;
                                                                                                                            (
                                                                                                                            destination: string | Bucket | File,
                                                                                                                            options: CopyOptions,
                                                                                                                            callback: CopyCallback
                                                                                                                            ): void;
                                                                                                                            };

                                                                                                                              method createReadStream

                                                                                                                              createReadStream: (options?: CreateReadStreamOptions) => Readable;
                                                                                                                              • Create a readable stream to read the contents of the remote file. It can be piped to a writable stream or listened to for 'data' events to read a file's contents.

                                                                                                                                In the unlikely event there is a mismatch between what you downloaded and the version in your Bucket, your error handler will receive an error with code "CONTENT_DOWNLOAD_MISMATCH". If you receive this error, the best recourse is to try downloading the file again.

                                                                                                                                NOTE: Readable streams will emit the end event when the file is fully downloaded.

                                                                                                                                Parameter options

                                                                                                                                Configuration options.

                                                                                                                                Returns

                                                                                                                                {ReadableStream}

                                                                                                                                Example 1

                                                                                                                                //-
                                                                                                                                // <h4>Downloading a File</h4>
                                                                                                                                //
                                                                                                                                // The example below demonstrates how we can reference a remote file, then
                                                                                                                                // pipe its contents to a local file. This is effectively creating a local
                                                                                                                                // backup of your remote data.
                                                                                                                                //-
                                                                                                                                const {Storage} = require('@google-cloud/storage');
                                                                                                                                const storage = new Storage();
                                                                                                                                const bucket = storage.bucket('my-bucket');
                                                                                                                                const fs = require('fs');
                                                                                                                                const remoteFile = bucket.file('image.png');
                                                                                                                                const localFilename = '/Users/stephen/Photos/image.png';
                                                                                                                                remoteFile.createReadStream()
                                                                                                                                .on('error', function(err) {})
                                                                                                                                .on('response', function(response) {
                                                                                                                                // Server connected and responded with the specified status and headers.
                                                                                                                                })
                                                                                                                                .on('end', function() {
                                                                                                                                // The file is fully downloaded.
                                                                                                                                })
                                                                                                                                .pipe(fs.createWriteStream(localFilename));
                                                                                                                                //-
                                                                                                                                // To limit the downloaded data to only a byte range, pass an options
                                                                                                                                // object.
                                                                                                                                //-
                                                                                                                                const logFile = myBucket.file('access_log');
                                                                                                                                logFile.createReadStream({
                                                                                                                                start: 10000,
                                                                                                                                end: 20000
                                                                                                                                })
                                                                                                                                .on('error', function(err) {})
                                                                                                                                .pipe(fs.createWriteStream('/Users/stephen/logfile.txt'));
                                                                                                                                //-
                                                                                                                                // To read a tail byte range, specify only `options.end` as a negative
                                                                                                                                // number.
                                                                                                                                //-
                                                                                                                                const logFile = myBucket.file('access_log');
                                                                                                                                logFile.createReadStream({
                                                                                                                                end: -100
                                                                                                                                })
                                                                                                                                .on('error', function(err) {})
                                                                                                                                .pipe(fs.createWriteStream('/Users/stephen/logfile.txt'));

                                                                                                                              method createResumableUpload

                                                                                                                              createResumableUpload: {
                                                                                                                              (
                                                                                                                              options?: CreateResumableUploadOptions
                                                                                                                              ): Promise<CreateResumableUploadResponse>;
                                                                                                                              (
                                                                                                                              options: CreateResumableUploadOptions,
                                                                                                                              callback: CreateResumableUploadCallback
                                                                                                                              ): void;
                                                                                                                              (callback: CreateResumableUploadCallback): void;
                                                                                                                              };

                                                                                                                                method createWriteStream

                                                                                                                                createWriteStream: (options?: CreateWriteStreamOptions) => Writable;
                                                                                                                                • Create a writable stream to overwrite the contents of the file in your bucket.

                                                                                                                                  A File object can also be used to create files for the first time.

                                                                                                                                  Resumable uploads are automatically enabled and must be shut off explicitly by setting options.resumable to false.

                                                                                                                                  There is some overhead when using a resumable upload that can cause noticeable performance degradation while uploading a series of small files. When uploading files less than 10MB, it is recommended that the resumable feature is disabled.

                                                                                                                                  NOTE: Writable streams will emit the finish event when the file is fully uploaded.

                                                                                                                                  See See

                                                                                                                                  Parameter options

                                                                                                                                  Configuration options.

                                                                                                                                  Returns

                                                                                                                                  {WritableStream}

                                                                                                                                  Example 1

                                                                                                                                  const fs = require('fs');
                                                                                                                                  const {Storage} = require('@google-cloud/storage');
                                                                                                                                  const storage = new Storage();
                                                                                                                                  const myBucket = storage.bucket('my-bucket');
                                                                                                                                  const file = myBucket.file('my-file');
                                                                                                                                  //-
                                                                                                                                  // <h4>Uploading a File</h4>
                                                                                                                                  //
                                                                                                                                  // Now, consider a case where we want to upload a file to your bucket. You
                                                                                                                                  // have the option of using {@link Bucket#upload}, but that is just
                                                                                                                                  // a convenience method which will do the following.
                                                                                                                                  //-
                                                                                                                                  fs.createReadStream('/Users/stephen/Photos/birthday-at-the-zoo/panda.jpg')
                                                                                                                                  .pipe(file.createWriteStream())
                                                                                                                                  .on('error', function(err) {})
                                                                                                                                  .on('finish', function() {
                                                                                                                                  // The file upload is complete.
                                                                                                                                  });
                                                                                                                                  //-
                                                                                                                                  // <h4>Uploading a File with gzip compression</h4>
                                                                                                                                  //-
                                                                                                                                  fs.createReadStream('/Users/stephen/site/index.html')
                                                                                                                                  .pipe(file.createWriteStream({ gzip: true }))
                                                                                                                                  .on('error', function(err) {})
                                                                                                                                  .on('finish', function() {
                                                                                                                                  // The file upload is complete.
                                                                                                                                  });
                                                                                                                                  //-
                                                                                                                                  // Downloading the file with `createReadStream` will automatically decode
                                                                                                                                  // the file.
                                                                                                                                  //-
                                                                                                                                  //-
                                                                                                                                  // <h4>Uploading a File with Metadata</h4>
                                                                                                                                  //
                                                                                                                                  // One last case you may run into is when you want to upload a file to your
                                                                                                                                  // bucket and set its metadata at the same time. Like above, you can use
                                                                                                                                  // {@link Bucket#upload} to do this, which is just a wrapper around
                                                                                                                                  // the following.
                                                                                                                                  //-
                                                                                                                                  fs.createReadStream('/Users/stephen/Photos/birthday-at-the-zoo/panda.jpg')
                                                                                                                                  .pipe(file.createWriteStream({
                                                                                                                                  metadata: {
                                                                                                                                  contentType: 'image/jpeg',
                                                                                                                                  metadata: {
                                                                                                                                  custom: 'metadata'
                                                                                                                                  }
                                                                                                                                  }
                                                                                                                                  }))
                                                                                                                                  .on('error', function(err) {})
                                                                                                                                  .on('finish', function() {
                                                                                                                                  // The file upload is complete.
                                                                                                                                  });

                                                                                                                                  //- // Continuing a Resumable Upload // // One can capture a uri from a resumable upload to reuse later. // Additionally, for validation, one can also capture and pass crc32c. //- let uri: string | undefined = undefined; let resumeCRC32C: string | undefined = undefined;

                                                                                                                                  fs.createWriteStream() .on('uri', link => {uri = link}) .on('crc32', crc32c => {resumeCRC32C = crc32c});

                                                                                                                                  // later... fs.createWriteStream({uri, resumeCRC32C});

                                                                                                                                method delete

                                                                                                                                delete: {
                                                                                                                                (options?: DeleteOptions): Promise<[r.Response]>;
                                                                                                                                (options: DeleteOptions, callback: DeleteCallback): void;
                                                                                                                                (callback: DeleteCallback): void;
                                                                                                                                };
                                                                                                                                • Delete the object.

                                                                                                                                  Parameter callback

                                                                                                                                  The callback function.

                                                                                                                                  Parameter

                                                                                                                                  {?error} callback.err - An error returned while making this request.

                                                                                                                                  Parameter

                                                                                                                                  {object} callback.apiResponse - The full API response.

                                                                                                                                method disableAutoRetryConditionallyIdempotent_

                                                                                                                                disableAutoRetryConditionallyIdempotent_: (
                                                                                                                                coreOpts: any,
                                                                                                                                methodType: AvailableServiceObjectMethods,
                                                                                                                                localPreconditionOptions?: PreconditionOptions
                                                                                                                                ) => void;

                                                                                                                                  method download

                                                                                                                                  download: {
                                                                                                                                  (options?: DownloadOptions): Promise<DownloadResponse>;
                                                                                                                                  (options: DownloadOptions, callback: DownloadCallback): void;
                                                                                                                                  (callback: DownloadCallback): void;
                                                                                                                                  };

                                                                                                                                    method from

                                                                                                                                    static from: (
                                                                                                                                    publicUrlOrGsUrl: string,
                                                                                                                                    storageInstance: Storage,
                                                                                                                                    options?: FileOptions
                                                                                                                                    ) => File;
                                                                                                                                    • Gets a reference to a Cloud Storage File file from the provided URL in string format.

                                                                                                                                      Parameter publicUrlOrGsUrl

                                                                                                                                      the URL as a string. Must be of the format gs://bucket/file or https://storage.googleapis.com/bucket/file.

                                                                                                                                      Parameter storageInstance

                                                                                                                                      an instance of a Storage object.

                                                                                                                                      Parameter options

                                                                                                                                      Configuration options

                                                                                                                                      Returns

                                                                                                                                      {File}

                                                                                                                                    method generateSignedPostPolicyV2

                                                                                                                                    generateSignedPostPolicyV2: {
                                                                                                                                    (
                                                                                                                                    options: GenerateSignedPostPolicyV2Options
                                                                                                                                    ): Promise<GenerateSignedPostPolicyV2Response>;
                                                                                                                                    (
                                                                                                                                    options: GenerateSignedPostPolicyV2Options,
                                                                                                                                    callback: GenerateSignedPostPolicyV2Callback
                                                                                                                                    ): void;
                                                                                                                                    (callback: GenerateSignedPostPolicyV2Callback): void;
                                                                                                                                    };

                                                                                                                                      method generateSignedPostPolicyV4

                                                                                                                                      generateSignedPostPolicyV4: {
                                                                                                                                      (
                                                                                                                                      options: GenerateSignedPostPolicyV4Options
                                                                                                                                      ): Promise<GenerateSignedPostPolicyV4Response>;
                                                                                                                                      (
                                                                                                                                      options: GenerateSignedPostPolicyV4Options,
                                                                                                                                      callback: GenerateSignedPostPolicyV4Callback
                                                                                                                                      ): void;
                                                                                                                                      (callback: GenerateSignedPostPolicyV4Callback): void;
                                                                                                                                      };

                                                                                                                                        method get

                                                                                                                                        get: {
                                                                                                                                        (options?: GetFileOptions): Promise<GetResponse<File>>;
                                                                                                                                        (callback: InstanceResponseCallback<File>): void;
                                                                                                                                        (options: GetFileOptions, callback: InstanceResponseCallback<File>): void;
                                                                                                                                        };

                                                                                                                                          method getExpirationDate

                                                                                                                                          getExpirationDate: {
                                                                                                                                          (): Promise<GetExpirationDateResponse>;
                                                                                                                                          (callback: GetExpirationDateCallback): void;
                                                                                                                                          };

                                                                                                                                            method getSignedUrl

                                                                                                                                            getSignedUrl: {
                                                                                                                                            (cfg: GetSignedUrlConfig): Promise<GetSignedUrlResponse>;
                                                                                                                                            (cfg: GetSignedUrlConfig, callback: GetSignedUrlCallback): void;
                                                                                                                                            };

                                                                                                                                              method isPublic

                                                                                                                                              isPublic: { (): Promise<IsPublicResponse>; (callback: IsPublicCallback): void };

                                                                                                                                                method makePrivate

                                                                                                                                                makePrivate: {
                                                                                                                                                (options?: MakeFilePrivateOptions): Promise<MakeFilePrivateResponse>;
                                                                                                                                                (callback: SetFileMetadataCallback): void;
                                                                                                                                                (options: MakeFilePrivateOptions, callback: SetFileMetadataCallback): void;
                                                                                                                                                };

                                                                                                                                                  method makePublic

                                                                                                                                                  makePublic: {
                                                                                                                                                  (): Promise<MakeFilePublicResponse>;
                                                                                                                                                  (callback: MakeFilePublicCallback): void;
                                                                                                                                                  };

                                                                                                                                                    method move

                                                                                                                                                    move: {
                                                                                                                                                    (
                                                                                                                                                    destination: string | Bucket | File,
                                                                                                                                                    options?: MoveOptions
                                                                                                                                                    ): Promise<MoveResponse>;
                                                                                                                                                    (destination: string | Bucket | File, callback: MoveCallback): void;
                                                                                                                                                    (
                                                                                                                                                    destination: string | Bucket | File,
                                                                                                                                                    options: MoveOptions,
                                                                                                                                                    callback: MoveCallback
                                                                                                                                                    ): void;
                                                                                                                                                    };

                                                                                                                                                      method moveFileAtomic

                                                                                                                                                      moveFileAtomic: {
                                                                                                                                                      (
                                                                                                                                                      destination: string | File,
                                                                                                                                                      options?: MoveFileAtomicOptions
                                                                                                                                                      ): Promise<MoveFileAtomicResponse>;
                                                                                                                                                      (destination: string | File, callback: MoveCallback): void;
                                                                                                                                                      (
                                                                                                                                                      destination: string | File,
                                                                                                                                                      options: MoveOptions,
                                                                                                                                                      callback: MoveCallback
                                                                                                                                                      ): void;
                                                                                                                                                      };

                                                                                                                                                        method publicUrl

                                                                                                                                                        publicUrl: () => string;
                                                                                                                                                        • The public URL of this File Use File#makePublic to enable anonymous access via the returned URL.

                                                                                                                                                          Returns

                                                                                                                                                          {string}

                                                                                                                                                          Example 1

                                                                                                                                                          const {Storage} = require('@google-cloud/storage');
                                                                                                                                                          const storage = new Storage();
                                                                                                                                                          const bucket = storage.bucket('albums');
                                                                                                                                                          const file = bucket.file('my-file');
                                                                                                                                                          // publicUrl will be "https://storage.googleapis.com/albums/my-file"
                                                                                                                                                          const publicUrl = file.publicUrl();

                                                                                                                                                        method rename

                                                                                                                                                        rename: {
                                                                                                                                                        (
                                                                                                                                                        destinationFile: string | File,
                                                                                                                                                        options?: RenameOptions
                                                                                                                                                        ): Promise<RenameResponse>;
                                                                                                                                                        (destinationFile: string | File, callback: MoveCallback): void;
                                                                                                                                                        (
                                                                                                                                                        destinationFile: string | File,
                                                                                                                                                        options: MoveOptions,
                                                                                                                                                        callback: MoveCallback
                                                                                                                                                        ): void;
                                                                                                                                                        };

                                                                                                                                                          method request

                                                                                                                                                          request: {
                                                                                                                                                          (reqOpts: DecorateRequestOptions): Promise<RequestResponse>;
                                                                                                                                                          (reqOpts: DecorateRequestOptions, callback: BodyResponseCallback): void;
                                                                                                                                                          };

                                                                                                                                                            method restore

                                                                                                                                                            restore: (options: RestoreOptions) => Promise<File>;
                                                                                                                                                            • Restores a soft-deleted file

                                                                                                                                                              Parameter options

                                                                                                                                                              Restore options.

                                                                                                                                                              Returns

                                                                                                                                                              {Promise}

                                                                                                                                                            method rotateEncryptionKey

                                                                                                                                                            rotateEncryptionKey: {
                                                                                                                                                            (options?: RotateEncryptionKeyOptions): Promise<RotateEncryptionKeyResponse>;
                                                                                                                                                            (callback: CopyCallback): void;
                                                                                                                                                            (options: any, callback: CopyCallback): void;
                                                                                                                                                            };

                                                                                                                                                              method save

                                                                                                                                                              save: {
                                                                                                                                                              (data: SaveData, options?: SaveOptions): Promise<void>;
                                                                                                                                                              (data: any, callback: SaveCallback): void;
                                                                                                                                                              (data: any, options: SaveOptions, callback: SaveCallback): void;
                                                                                                                                                              };

                                                                                                                                                                method setEncryptionKey

                                                                                                                                                                setEncryptionKey: (encryptionKey: string | Buffer) => this;
                                                                                                                                                                • The Storage API allows you to use a custom key for server-side encryption.

                                                                                                                                                                  See Customer-supplied Encryption Keys

                                                                                                                                                                  Parameter encryptionKey

                                                                                                                                                                  An AES-256 encryption key.

                                                                                                                                                                  Returns

                                                                                                                                                                  {File}

                                                                                                                                                                  Example 1

                                                                                                                                                                  const crypto = require('crypto');
                                                                                                                                                                  const {Storage} = require('@google-cloud/storage');
                                                                                                                                                                  const storage = new Storage();
                                                                                                                                                                  const myBucket = storage.bucket('my-bucket');
                                                                                                                                                                  const encryptionKey = crypto.randomBytes(32);
                                                                                                                                                                  const fileWithCustomEncryption = myBucket.file('my-file');
                                                                                                                                                                  fileWithCustomEncryption.setEncryptionKey(encryptionKey);
                                                                                                                                                                  const fileWithoutCustomEncryption = myBucket.file('my-file');
                                                                                                                                                                  fileWithCustomEncryption.save('data', function(err) {
                                                                                                                                                                  // Try to download with the File object that hasn't had
                                                                                                                                                                  // `setEncryptionKey()` called:
                                                                                                                                                                  fileWithoutCustomEncryption.download(function(err) {
                                                                                                                                                                  // We will receive an error:
                                                                                                                                                                  // err.message === 'Bad Request'
                                                                                                                                                                  // Try again with the File object we called `setEncryptionKey()` on:
                                                                                                                                                                  fileWithCustomEncryption.download(function(err, contents) {
                                                                                                                                                                  // contents.toString() === 'data'
                                                                                                                                                                  });
                                                                                                                                                                  });
                                                                                                                                                                  });

                                                                                                                                                                  Example 2

                                                                                                                                                                  include:samples/encryption.js region_tag:storage_upload_encrypted_file Example of uploading an encrypted file:

                                                                                                                                                                  Example 3

                                                                                                                                                                  include:samples/encryption.js region_tag:storage_download_encrypted_file Example of downloading an encrypted file:

                                                                                                                                                                method setMetadata

                                                                                                                                                                setMetadata: {
                                                                                                                                                                (metadata: FileMetadata, options?: SetMetadataOptions): Promise<
                                                                                                                                                                SetMetadataResponse<FileMetadata>
                                                                                                                                                                >;
                                                                                                                                                                (metadata: FileMetadata, callback: MetadataCallback<FileMetadata>): void;
                                                                                                                                                                (
                                                                                                                                                                metadata: FileMetadata,
                                                                                                                                                                options: object,
                                                                                                                                                                callback: MetadataCallback<FileMetadata>
                                                                                                                                                                ): void;
                                                                                                                                                                };

                                                                                                                                                                  method setStorageClass

                                                                                                                                                                  setStorageClass: {
                                                                                                                                                                  (
                                                                                                                                                                  storageClass: string,
                                                                                                                                                                  options?: SetStorageClassOptions
                                                                                                                                                                  ): Promise<SetStorageClassResponse>;
                                                                                                                                                                  (
                                                                                                                                                                  storageClass: string,
                                                                                                                                                                  options: SetStorageClassOptions,
                                                                                                                                                                  callback: SetStorageClassCallback
                                                                                                                                                                  ): void;
                                                                                                                                                                  (storageClass: string, callback?: SetStorageClassCallback): void;
                                                                                                                                                                  };

                                                                                                                                                                    method setUserProject

                                                                                                                                                                    setUserProject: (userProject: string) => void;
                                                                                                                                                                    • Set a user project to be billed for all requests made from this File object.

                                                                                                                                                                      Parameter userProject

                                                                                                                                                                      The user project.

                                                                                                                                                                      Example 1

                                                                                                                                                                      const {Storage} = require('@google-cloud/storage');
                                                                                                                                                                      const storage = new Storage();
                                                                                                                                                                      const bucket = storage.bucket('albums');
                                                                                                                                                                      const file = bucket.file('my-file');
                                                                                                                                                                      file.setUserProject('grape-spaceship-123');

                                                                                                                                                                    method startResumableUpload_

                                                                                                                                                                    startResumableUpload_: (
                                                                                                                                                                    dup: Duplexify,
                                                                                                                                                                    options?: CreateResumableUploadOptions
                                                                                                                                                                    ) => void;
                                                                                                                                                                    • This creates a resumable-upload upload stream.

                                                                                                                                                                      Parameter stream

                                                                                                                                                                      Duplexify stream of data to pipe to the file.

                                                                                                                                                                      Parameter options

                                                                                                                                                                      Configuration object.

                                                                                                                                                                    method startSimpleUpload_

                                                                                                                                                                    startSimpleUpload_: (dup: Duplexify, options?: CreateWriteStreamOptions) => void;
                                                                                                                                                                    • Takes a readable stream and pipes it to a remote file. Unlike startResumableUpload_, which uses the resumable upload technique, this method uses a simple upload (all or nothing).

                                                                                                                                                                      Parameter dup

                                                                                                                                                                      Duplexify stream of data to pipe to the file.

                                                                                                                                                                      Parameter options

                                                                                                                                                                      Configuration object.

                                                                                                                                                                    class HashStreamValidator

                                                                                                                                                                    class HashStreamValidator extends Transform {}

                                                                                                                                                                      constructor

                                                                                                                                                                      constructor(options?: Partial<HashStreamValidatorOptions>);

                                                                                                                                                                        property crc32c

                                                                                                                                                                        readonly crc32c: string;
                                                                                                                                                                        • Return the current CRC32C value, if available.

                                                                                                                                                                        property crc32cEnabled

                                                                                                                                                                        readonly crc32cEnabled: boolean;

                                                                                                                                                                          property crc32cExpected

                                                                                                                                                                          readonly crc32cExpected: string;

                                                                                                                                                                            property md5Enabled

                                                                                                                                                                            readonly md5Enabled: boolean;

                                                                                                                                                                              property md5Expected

                                                                                                                                                                              readonly md5Expected: string;

                                                                                                                                                                                property updateHashesOnly

                                                                                                                                                                                readonly updateHashesOnly: boolean;

                                                                                                                                                                                  method test

                                                                                                                                                                                  test: (hash: 'crc32c' | 'md5', sum: Buffer | string) => boolean;

                                                                                                                                                                                    class HmacKey

                                                                                                                                                                                    class HmacKey extends ServiceObject<HmacKey, HmacKeyMetadata> {}

                                                                                                                                                                                    constructor

                                                                                                                                                                                    constructor(storage: Storage, accessId: string, options?: HmacKeyOptions);
                                                                                                                                                                                    • Constructs an HmacKey object.

                                                                                                                                                                                      Note: this only create a local reference to an HMAC key, to create an HMAC key, use Storage#createHmacKey.

                                                                                                                                                                                      Parameter storage

                                                                                                                                                                                      The Storage instance this HMAC key is attached to.

                                                                                                                                                                                      Parameter accessId

                                                                                                                                                                                      The unique accessId for this HMAC key.

                                                                                                                                                                                      Parameter options

                                                                                                                                                                                      Constructor configurations.

                                                                                                                                                                                      Example 1

                                                                                                                                                                                      const {Storage} = require('@google-cloud/storage');
                                                                                                                                                                                      const storage = new Storage();
                                                                                                                                                                                      const hmacKey = storage.hmacKey('access-id');

                                                                                                                                                                                    property storage

                                                                                                                                                                                    storage: Storage;
                                                                                                                                                                                    • A reference to the Storage associated with this HmacKey instance. HmacKey#storage {Storage}

                                                                                                                                                                                    method setMetadata

                                                                                                                                                                                    setMetadata: {
                                                                                                                                                                                    (metadata: HmacKeyMetadata, options?: SetMetadataOptions): Promise<
                                                                                                                                                                                    SetMetadataResponse<HmacKeyMetadata>
                                                                                                                                                                                    >;
                                                                                                                                                                                    (
                                                                                                                                                                                    metadata: HmacKeyMetadata,
                                                                                                                                                                                    callback: MetadataCallback<HmacKeyMetadata>
                                                                                                                                                                                    ): void;
                                                                                                                                                                                    (
                                                                                                                                                                                    metadata: HmacKeyMetadata,
                                                                                                                                                                                    options: object,
                                                                                                                                                                                    callback: MetadataCallback<HmacKeyMetadata>
                                                                                                                                                                                    ): void;
                                                                                                                                                                                    };
                                                                                                                                                                                    • Set the metadata for this object.

                                                                                                                                                                                      Parameter metadata

                                                                                                                                                                                      The metadata to set on this object.

                                                                                                                                                                                      Parameter options

                                                                                                                                                                                      Configuration options.

                                                                                                                                                                                      Parameter callback

                                                                                                                                                                                      The callback function.

                                                                                                                                                                                      Parameter

                                                                                                                                                                                      {?error} callback.err - An error returned while making this request.

                                                                                                                                                                                      Parameter

                                                                                                                                                                                      {object} callback.apiResponse - The full API response.

                                                                                                                                                                                    class Iam

                                                                                                                                                                                    class Iam {}

                                                                                                                                                                                    constructor

                                                                                                                                                                                    constructor(bucket: Bucket);

                                                                                                                                                                                      method getPolicy

                                                                                                                                                                                      getPolicy: {
                                                                                                                                                                                      (options?: GetPolicyOptions): Promise<GetPolicyResponse>;
                                                                                                                                                                                      (options: GetPolicyOptions, callback: GetPolicyCallback): void;
                                                                                                                                                                                      (callback: GetPolicyCallback): void;
                                                                                                                                                                                      };

                                                                                                                                                                                        method setPolicy

                                                                                                                                                                                        setPolicy: {
                                                                                                                                                                                        (policy: Policy, options?: SetPolicyOptions): Promise<SetPolicyResponse>;
                                                                                                                                                                                        (policy: Policy, callback: SetPolicyCallback): void;
                                                                                                                                                                                        (
                                                                                                                                                                                        policy: Policy,
                                                                                                                                                                                        options: SetPolicyOptions,
                                                                                                                                                                                        callback: SetPolicyCallback
                                                                                                                                                                                        ): void;
                                                                                                                                                                                        };

                                                                                                                                                                                          method testPermissions

                                                                                                                                                                                          testPermissions: {
                                                                                                                                                                                          (
                                                                                                                                                                                          permissions: string | string[],
                                                                                                                                                                                          options?: TestIamPermissionsOptions
                                                                                                                                                                                          ): Promise<TestIamPermissionsResponse>;
                                                                                                                                                                                          (permissions: string | string[], callback: TestIamPermissionsCallback): void;
                                                                                                                                                                                          (
                                                                                                                                                                                          permissions: string | string[],
                                                                                                                                                                                          options: TestIamPermissionsOptions,
                                                                                                                                                                                          callback: TestIamPermissionsCallback
                                                                                                                                                                                          ): void;
                                                                                                                                                                                          };

                                                                                                                                                                                            class MultiPartUploadError

                                                                                                                                                                                            class MultiPartUploadError extends Error {}

                                                                                                                                                                                              constructor

                                                                                                                                                                                              constructor(message: string, uploadId: string, partsMap: Map<number, string>);

                                                                                                                                                                                                class Notification

                                                                                                                                                                                                class Notification extends ServiceObject<Notification, NotificationMetadata> {}
                                                                                                                                                                                                • A Notification object is created from your Bucket object using Bucket#notification. Use it to interact with Cloud Pub/Sub notifications.

                                                                                                                                                                                                  See Cloud Pub/Sub Notifications for Google Cloud Storage

                                                                                                                                                                                                  Parameter bucket

                                                                                                                                                                                                  The bucket instance this notification is attached to.

                                                                                                                                                                                                  Parameter id

                                                                                                                                                                                                  The ID of the notification.

                                                                                                                                                                                                  Example 1

                                                                                                                                                                                                  const {Storage} = require('@google-cloud/storage');
                                                                                                                                                                                                  const storage = new Storage();
                                                                                                                                                                                                  const myBucket = storage.bucket('my-bucket');
                                                                                                                                                                                                  const notification = myBucket.notification('1');

                                                                                                                                                                                                constructor

                                                                                                                                                                                                constructor(bucket: Bucket, id: string);

                                                                                                                                                                                                  class Storage

                                                                                                                                                                                                  class Storage extends Service {}
                                                                                                                                                                                                  • ACLs Cloud Storage uses access control lists (ACLs) to manage object and bucket access. ACLs are the mechanism you use to share files with other users and allow other users to access your buckets and files.

                                                                                                                                                                                                    To learn more about ACLs, read this overview on Access Control.

                                                                                                                                                                                                    See Cloud Storage overview See Access Control

                                                                                                                                                                                                  constructor

                                                                                                                                                                                                  constructor(options?: StorageOptions);
                                                                                                                                                                                                  • Constructs the Storage client.

                                                                                                                                                                                                    Parameter options

                                                                                                                                                                                                    Configuration options.

                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                    Create a client that uses Application Default Credentials (ADC)

                                                                                                                                                                                                    const {Storage} = require('@google-cloud/storage');
                                                                                                                                                                                                    const storage = new Storage();

                                                                                                                                                                                                    Example 2

                                                                                                                                                                                                    Create a client with explicit credentials

                                                                                                                                                                                                    const storage = new Storage({
                                                                                                                                                                                                    projectId: 'your-project-id',
                                                                                                                                                                                                    keyFilename: '/path/to/keyfile.json'
                                                                                                                                                                                                    });

                                                                                                                                                                                                    Example 3

                                                                                                                                                                                                    Create a client with credentials passed by value as a JavaScript object

                                                                                                                                                                                                    const storage = new Storage({
                                                                                                                                                                                                    projectId: 'your-project-id',
                                                                                                                                                                                                    credentials: {
                                                                                                                                                                                                    type: 'service_account',
                                                                                                                                                                                                    project_id: 'xxxxxxx',
                                                                                                                                                                                                    private_key_id: 'xxxx',
                                                                                                                                                                                                    private_key:'-----BEGIN PRIVATE KEY-----xxxxxxx\n-----END PRIVATE KEY-----\n',
                                                                                                                                                                                                    client_email: 'xxxx',
                                                                                                                                                                                                    client_id: 'xxx',
                                                                                                                                                                                                    auth_uri: 'https://accounts.google.com/o/oauth2/auth',
                                                                                                                                                                                                    token_uri: 'https://oauth2.googleapis.com/token',
                                                                                                                                                                                                    auth_provider_x509_cert_url: 'https://www.googleapis.com/oauth2/v1/certs',
                                                                                                                                                                                                    client_x509_cert_url: 'xxx',
                                                                                                                                                                                                    }
                                                                                                                                                                                                    });

                                                                                                                                                                                                    Example 4

                                                                                                                                                                                                    Create a client with credentials passed by loading a JSON file directly from disk

                                                                                                                                                                                                    const storage = new Storage({
                                                                                                                                                                                                    projectId: 'your-project-id',
                                                                                                                                                                                                    credentials: require('/path/to-keyfile.json')
                                                                                                                                                                                                    });

                                                                                                                                                                                                    Example 5

                                                                                                                                                                                                    Create a client with an AuthClient (e.g. DownscopedClient)

                                                                                                                                                                                                    const {DownscopedClient} = require('google-auth-library');
                                                                                                                                                                                                    const authClient = new DownscopedClient({...});
                                                                                                                                                                                                    const storage = new Storage({authClient});

                                                                                                                                                                                                    Additional samples: - https://github.com/googleapis/google-auth-library-nodejs#sample-usage-1 - https://github.com/googleapis/google-auth-library-nodejs/blob/main/samples/downscopedclient.js

                                                                                                                                                                                                  property acl

                                                                                                                                                                                                  static acl: { OWNER_ROLE: string; READER_ROLE: string; WRITER_ROLE: string };

                                                                                                                                                                                                    property acl

                                                                                                                                                                                                    acl: { OWNER_ROLE: string; READER_ROLE: string; WRITER_ROLE: string };
                                                                                                                                                                                                    • Reference to Storage.acl.

                                                                                                                                                                                                      Storage#acl

                                                                                                                                                                                                      See Also

                                                                                                                                                                                                      • Storage.acl

                                                                                                                                                                                                    property Bucket

                                                                                                                                                                                                    static Bucket: typeof Bucket;
                                                                                                                                                                                                    • Bucket class.

                                                                                                                                                                                                      Storage.Bucket

                                                                                                                                                                                                      See Also

                                                                                                                                                                                                      • Bucket {Constructor}

                                                                                                                                                                                                    property Channel

                                                                                                                                                                                                    static Channel: typeof Channel;
                                                                                                                                                                                                    • Channel class.

                                                                                                                                                                                                      Storage.Channel

                                                                                                                                                                                                      See Also

                                                                                                                                                                                                      • Channel {Constructor}

                                                                                                                                                                                                    property crc32cGenerator

                                                                                                                                                                                                    crc32cGenerator: CRC32CValidatorGenerator;

                                                                                                                                                                                                      property File

                                                                                                                                                                                                      static File: typeof File;
                                                                                                                                                                                                      • File class.

                                                                                                                                                                                                        Storage.File

                                                                                                                                                                                                        See Also

                                                                                                                                                                                                        • File {Constructor}

                                                                                                                                                                                                      property HmacKey

                                                                                                                                                                                                      static HmacKey: typeof HmacKey;
                                                                                                                                                                                                      • HmacKey class.

                                                                                                                                                                                                        Storage.HmacKey

                                                                                                                                                                                                        See Also

                                                                                                                                                                                                        • HmacKey {Constructor}

                                                                                                                                                                                                      property retryOptions

                                                                                                                                                                                                      retryOptions: RetryOptions;

                                                                                                                                                                                                        method bucket

                                                                                                                                                                                                        bucket: (name: string, options?: BucketOptions) => Bucket;
                                                                                                                                                                                                        • Get a reference to a Cloud Storage bucket.

                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                          Name of the bucket.

                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                          Configuration object.

                                                                                                                                                                                                          Parameter

                                                                                                                                                                                                          {string} [options.kmsKeyName] A Cloud KMS key that will be used to encrypt objects inserted into this bucket, if no encryption method is specified.

                                                                                                                                                                                                          Parameter

                                                                                                                                                                                                          {string} [options.userProject] User project to be billed for all requests made from this Bucket object.

                                                                                                                                                                                                          Returns

                                                                                                                                                                                                          {Bucket}

                                                                                                                                                                                                          Example 1

                                                                                                                                                                                                          const {Storage} = require('@google-cloud/storage');
                                                                                                                                                                                                          const storage = new Storage();
                                                                                                                                                                                                          const albums = storage.bucket('albums');
                                                                                                                                                                                                          const photos = storage.bucket('photos');

                                                                                                                                                                                                          See Also

                                                                                                                                                                                                          • Bucket

                                                                                                                                                                                                        method channel

                                                                                                                                                                                                        channel: (id: string, resourceId: string) => Channel;
                                                                                                                                                                                                        • Reference a channel to receive notifications about changes to your bucket.

                                                                                                                                                                                                          Parameter id

                                                                                                                                                                                                          The ID of the channel.

                                                                                                                                                                                                          Parameter resourceId

                                                                                                                                                                                                          The resource ID of the channel.

                                                                                                                                                                                                          Returns

                                                                                                                                                                                                          {Channel}

                                                                                                                                                                                                          Example 1

                                                                                                                                                                                                          const {Storage} = require('@google-cloud/storage');
                                                                                                                                                                                                          const storage = new Storage();
                                                                                                                                                                                                          const channel = storage.channel('id', 'resource-id');

                                                                                                                                                                                                          See Also

                                                                                                                                                                                                          • Channel

                                                                                                                                                                                                        method createBucket

                                                                                                                                                                                                        createBucket: {
                                                                                                                                                                                                        (
                                                                                                                                                                                                        name: string,
                                                                                                                                                                                                        metadata?: CreateBucketRequest
                                                                                                                                                                                                        ): Promise<CreateBucketResponse>;
                                                                                                                                                                                                        (name: string, callback: BucketCallback): void;
                                                                                                                                                                                                        (
                                                                                                                                                                                                        name: string,
                                                                                                                                                                                                        metadata: CreateBucketRequest,
                                                                                                                                                                                                        callback: BucketCallback
                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                        (
                                                                                                                                                                                                        name: string,
                                                                                                                                                                                                        metadata: CreateBucketRequest,
                                                                                                                                                                                                        callback: BucketCallback
                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                        };

                                                                                                                                                                                                          method createHmacKey

                                                                                                                                                                                                          createHmacKey: {
                                                                                                                                                                                                          (
                                                                                                                                                                                                          serviceAccountEmail: string,
                                                                                                                                                                                                          options?: CreateHmacKeyOptions
                                                                                                                                                                                                          ): Promise<CreateHmacKeyResponse>;
                                                                                                                                                                                                          (serviceAccountEmail: string, callback: CreateHmacKeyCallback): void;
                                                                                                                                                                                                          (
                                                                                                                                                                                                          serviceAccountEmail: string,
                                                                                                                                                                                                          options: CreateHmacKeyOptions,
                                                                                                                                                                                                          callback: CreateHmacKeyCallback
                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                          };

                                                                                                                                                                                                            method getBuckets

                                                                                                                                                                                                            getBuckets: {
                                                                                                                                                                                                            (options?: GetBucketsRequest): Promise<GetBucketsResponse>;
                                                                                                                                                                                                            (options: GetBucketsRequest, callback: GetBucketsCallback): void;
                                                                                                                                                                                                            (callback: GetBucketsCallback): void;
                                                                                                                                                                                                            };

                                                                                                                                                                                                              method getBucketsStream

                                                                                                                                                                                                              getBucketsStream: () => Readable;

                                                                                                                                                                                                                method getHmacKeys

                                                                                                                                                                                                                getHmacKeys: {
                                                                                                                                                                                                                (options?: GetHmacKeysOptions): Promise<GetHmacKeysResponse>;
                                                                                                                                                                                                                (callback: GetHmacKeysCallback): void;
                                                                                                                                                                                                                (options: GetHmacKeysOptions, callback: GetHmacKeysCallback): void;
                                                                                                                                                                                                                };
                                                                                                                                                                                                                • Retrieves a list of HMAC keys matching the criteria.

                                                                                                                                                                                                                  The authenticated user must have storage.hmacKeys.list permission for the project in which the key exists.

                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                  Configuration options.

                                                                                                                                                                                                                  Parameter callback

                                                                                                                                                                                                                  Callback function. {Promise}

                                                                                                                                                                                                                  Example 1

                                                                                                                                                                                                                  const {Storage} = require('@google-cloud/storage');
                                                                                                                                                                                                                  const storage = new Storage();
                                                                                                                                                                                                                  storage.getHmacKeys(function(err, hmacKeys) {
                                                                                                                                                                                                                  if (!err) {
                                                                                                                                                                                                                  // hmacKeys is an array of HmacKey objects.
                                                                                                                                                                                                                  }
                                                                                                                                                                                                                  });
                                                                                                                                                                                                                  //-
                                                                                                                                                                                                                  // To control how many API requests are made and page through the results
                                                                                                                                                                                                                  // manually, set `autoPaginate` to `false`.
                                                                                                                                                                                                                  //-
                                                                                                                                                                                                                  const callback = function(err, hmacKeys, nextQuery, apiResponse) {
                                                                                                                                                                                                                  if (nextQuery) {
                                                                                                                                                                                                                  // More results exist.
                                                                                                                                                                                                                  storage.getHmacKeys(nextQuery, callback);
                                                                                                                                                                                                                  }
                                                                                                                                                                                                                  // The `metadata` property is populated for you with the metadata at the
                                                                                                                                                                                                                  // time of fetching.
                                                                                                                                                                                                                  hmacKeys[0].metadata;
                                                                                                                                                                                                                  };
                                                                                                                                                                                                                  storage.getHmacKeys({
                                                                                                                                                                                                                  autoPaginate: false
                                                                                                                                                                                                                  }, callback);
                                                                                                                                                                                                                  //-
                                                                                                                                                                                                                  // If the callback is omitted, we'll return a Promise.
                                                                                                                                                                                                                  //-
                                                                                                                                                                                                                  storage.getHmacKeys().then(function(data) {
                                                                                                                                                                                                                  const hmacKeys = data[0];
                                                                                                                                                                                                                  });

                                                                                                                                                                                                                method getHmacKeysStream

                                                                                                                                                                                                                getHmacKeysStream: () => Readable;

                                                                                                                                                                                                                  method getServiceAccount

                                                                                                                                                                                                                  getServiceAccount: {
                                                                                                                                                                                                                  (options?: GetServiceAccountOptions): Promise<GetServiceAccountResponse>;
                                                                                                                                                                                                                  (options?: GetServiceAccountOptions): Promise<GetServiceAccountResponse>;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  options: GetServiceAccountOptions,
                                                                                                                                                                                                                  callback: GetServiceAccountCallback
                                                                                                                                                                                                                  ): void;
                                                                                                                                                                                                                  (callback: GetServiceAccountCallback): void;
                                                                                                                                                                                                                  };

                                                                                                                                                                                                                    method hmacKey

                                                                                                                                                                                                                    hmacKey: (accessId: string, options?: HmacKeyOptions) => HmacKey;
                                                                                                                                                                                                                    • Get a reference to an HmacKey object. Note: this does not fetch the HMAC key's metadata. Use HmacKey#get() to retrieve and populate the metadata.

                                                                                                                                                                                                                      To get a reference to an HMAC key that's not created for a service account in the same project used to instantiate the Storage client, supply the project's ID as projectId in the options argument.

                                                                                                                                                                                                                      Parameter accessId

                                                                                                                                                                                                                      The HMAC key's access ID.

                                                                                                                                                                                                                      Parameter options

                                                                                                                                                                                                                      HmacKey constructor options.

                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                      {HmacKey}

                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                      const {Storage} = require('@google-cloud/storage');
                                                                                                                                                                                                                      const storage = new Storage();
                                                                                                                                                                                                                      const hmacKey = storage.hmacKey('ACCESS_ID');

                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                      • HmacKey

                                                                                                                                                                                                                    class TransferManager

                                                                                                                                                                                                                    class TransferManager {}
                                                                                                                                                                                                                    • Create a TransferManager object to perform parallel transfer operations on a Cloud Storage bucket.

                                                                                                                                                                                                                      Parameter bucket

                                                                                                                                                                                                                      A Bucket instance

                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                    constructor(bucket: Bucket);

                                                                                                                                                                                                                      property bucket

                                                                                                                                                                                                                      bucket: Bucket;

                                                                                                                                                                                                                        method downloadFileInChunks

                                                                                                                                                                                                                        downloadFileInChunks: (
                                                                                                                                                                                                                        fileOrName: File | string,
                                                                                                                                                                                                                        options?: DownloadFileInChunksOptions
                                                                                                                                                                                                                        ) => Promise<void | DownloadResponse>;
                                                                                                                                                                                                                        • Download a large file in chunks utilizing parallel download operations. This is a convenience method that utilizes File#download to perform the download.

                                                                                                                                                                                                                          Parameter fileOrName

                                                                                                                                                                                                                          File to download.

                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                          Configuration options.

                                                                                                                                                                                                                          Returns

                                                                                                                                                                                                                          {Promise<void | DownloadResponse>}

                                                                                                                                                                                                                          Example 1

                                                                                                                                                                                                                          const {Storage} = require('@google-cloud/storage');
                                                                                                                                                                                                                          const storage = new Storage();
                                                                                                                                                                                                                          const bucket = storage.bucket('my-bucket');
                                                                                                                                                                                                                          const transferManager = new TransferManager(bucket);
                                                                                                                                                                                                                          //-
                                                                                                                                                                                                                          // Download a large file in chunks utilizing parallel operations.
                                                                                                                                                                                                                          //-
                                                                                                                                                                                                                          const response = await transferManager.downloadFileInChunks(bucket.file('large-file.txt');
                                                                                                                                                                                                                          // Your local directory now contains:
                                                                                                                                                                                                                          // - "large-file.txt" (with the contents from my-bucket.large-file.txt)

                                                                                                                                                                                                                        method downloadManyFiles

                                                                                                                                                                                                                        downloadManyFiles: (
                                                                                                                                                                                                                        filesOrFolder: File[] | string[] | string,
                                                                                                                                                                                                                        options?: DownloadManyFilesOptions
                                                                                                                                                                                                                        ) => Promise<void | DownloadResponse[]>;
                                                                                                                                                                                                                        • Download multiple files in parallel to the local filesystem. This is a convenience method that utilizes File#download to perform the download.

                                                                                                                                                                                                                          Parameter filesOrFolder

                                                                                                                                                                                                                          An array of file name strings or file objects to be downloaded. If a string is provided this will be treated as a GCS prefix and all files with that prefix will be downloaded.

                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                          Configuration options. Setting options.prefix or options.stripPrefix or options.passthroughOptions.destination will cause the downloaded files to be written to the file system instead of being returned as a buffer.

                                                                                                                                                                                                                          Returns

                                                                                                                                                                                                                          {Promise<DownloadResponse[]>}

                                                                                                                                                                                                                          Example 1

                                                                                                                                                                                                                          const {Storage} = require('@google-cloud/storage');
                                                                                                                                                                                                                          const storage = new Storage();
                                                                                                                                                                                                                          const bucket = storage.bucket('my-bucket');
                                                                                                                                                                                                                          const transferManager = new TransferManager(bucket);
                                                                                                                                                                                                                          //-
                                                                                                                                                                                                                          // Download multiple files in parallel.
                                                                                                                                                                                                                          //-
                                                                                                                                                                                                                          const response = await transferManager.downloadManyFiles(['file1.txt', 'file2.txt']);
                                                                                                                                                                                                                          // The following files have been downloaded:
                                                                                                                                                                                                                          // - "file1.txt" (with the contents from my-bucket.file1.txt)
                                                                                                                                                                                                                          // - "file2.txt" (with the contents from my-bucket.file2.txt)
                                                                                                                                                                                                                          const response = await transferManager.downloadManyFiles([bucket.File('file1.txt'), bucket.File('file2.txt')]);
                                                                                                                                                                                                                          // The following files have been downloaded:
                                                                                                                                                                                                                          // - "file1.txt" (with the contents from my-bucket.file1.txt)
                                                                                                                                                                                                                          // - "file2.txt" (with the contents from my-bucket.file2.txt)
                                                                                                                                                                                                                          const response = await transferManager.downloadManyFiles('test-folder');
                                                                                                                                                                                                                          // All files with GCS prefix of 'test-folder' have been downloaded.

                                                                                                                                                                                                                        method uploadFileInChunks

                                                                                                                                                                                                                        uploadFileInChunks: (
                                                                                                                                                                                                                        filePath: string,
                                                                                                                                                                                                                        options?: UploadFileInChunksOptions,
                                                                                                                                                                                                                        generator?: MultiPartHelperGenerator
                                                                                                                                                                                                                        ) => Promise<GaxiosResponse | undefined>;
                                                                                                                                                                                                                        • Upload a large file in chunks utilizing parallel upload opertions. If the upload fails, an uploadId and map containing all the successfully uploaded parts will be returned to the caller. These arguments can be used to resume the upload.

                                                                                                                                                                                                                          Parameter filePath

                                                                                                                                                                                                                          The path of the file to be uploaded

                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                          Configuration options.

                                                                                                                                                                                                                          Parameter generator

                                                                                                                                                                                                                          A function that will return a type that implements the MPU interface. Most users will not need to use this.

                                                                                                                                                                                                                          Returns

                                                                                                                                                                                                                          {Promise} If successful a promise resolving to void, otherwise a error containing the message, uploadid, and parts map.

                                                                                                                                                                                                                          Example 1

                                                                                                                                                                                                                          const {Storage} = require('@google-cloud/storage');
                                                                                                                                                                                                                          const storage = new Storage();
                                                                                                                                                                                                                          const bucket = storage.bucket('my-bucket');
                                                                                                                                                                                                                          const transferManager = new TransferManager(bucket);
                                                                                                                                                                                                                          //-
                                                                                                                                                                                                                          // Upload a large file in chunks utilizing parallel operations.
                                                                                                                                                                                                                          //-
                                                                                                                                                                                                                          const response = await transferManager.uploadFileInChunks('large-file.txt');
                                                                                                                                                                                                                          // Your bucket now contains:
                                                                                                                                                                                                                          // - "large-file.txt"

                                                                                                                                                                                                                        method uploadManyFiles

                                                                                                                                                                                                                        uploadManyFiles: (
                                                                                                                                                                                                                        filePathsOrDirectory: string[] | string,
                                                                                                                                                                                                                        options?: UploadManyFilesOptions
                                                                                                                                                                                                                        ) => Promise<UploadResponse[]>;
                                                                                                                                                                                                                        • Upload multiple files in parallel to the bucket. This is a convenience method that utilizes Bucket#upload to perform the upload.

                                                                                                                                                                                                                          Parameter filePathsOrDirectory

                                                                                                                                                                                                                          An array of fully qualified paths to the files or a directory name. If a directory name is provided, the directory will be recursively walked and all files will be added to the upload list. to be uploaded to the bucket

                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                          Configuration options.

                                                                                                                                                                                                                          Returns

                                                                                                                                                                                                                          {Promise<UploadResponse[]>}

                                                                                                                                                                                                                          Example 1

                                                                                                                                                                                                                          const {Storage} = require('@google-cloud/storage');
                                                                                                                                                                                                                          const storage = new Storage();
                                                                                                                                                                                                                          const bucket = storage.bucket('my-bucket');
                                                                                                                                                                                                                          const transferManager = new TransferManager(bucket);
                                                                                                                                                                                                                          //-
                                                                                                                                                                                                                          // Upload multiple files in parallel.
                                                                                                                                                                                                                          //-
                                                                                                                                                                                                                          const response = await transferManager.uploadManyFiles(['/local/path/file1.txt, 'local/path/file2.txt']);
                                                                                                                                                                                                                          // Your bucket now contains:
                                                                                                                                                                                                                          // - "local/path/file1.txt" (with the contents of '/local/path/file1.txt')
                                                                                                                                                                                                                          // - "local/path/file2.txt" (with the contents of '/local/path/file2.txt')
                                                                                                                                                                                                                          const response = await transferManager.uploadManyFiles('/local/directory');
                                                                                                                                                                                                                          // Your bucket will now contain all files contained in '/local/directory' maintaining the subdirectory structure.

                                                                                                                                                                                                                        Interfaces

                                                                                                                                                                                                                        interface AccessControlObject

                                                                                                                                                                                                                        interface AccessControlObject {}

                                                                                                                                                                                                                          property entity

                                                                                                                                                                                                                          entity: string;

                                                                                                                                                                                                                            property projectTeam

                                                                                                                                                                                                                            projectTeam: string;

                                                                                                                                                                                                                              property role

                                                                                                                                                                                                                              role: string;

                                                                                                                                                                                                                                interface AclMetadata

                                                                                                                                                                                                                                interface AclMetadata extends BaseMetadata {}

                                                                                                                                                                                                                                  property bucket

                                                                                                                                                                                                                                  bucket?: string;

                                                                                                                                                                                                                                    property domain

                                                                                                                                                                                                                                    domain?: string;

                                                                                                                                                                                                                                      property entity

                                                                                                                                                                                                                                      entity?: string;

                                                                                                                                                                                                                                        property entityId

                                                                                                                                                                                                                                        entityId?: string;

                                                                                                                                                                                                                                          property generation

                                                                                                                                                                                                                                          generation?: string;

                                                                                                                                                                                                                                            property object

                                                                                                                                                                                                                                            object?: string;

                                                                                                                                                                                                                                              property projectTeam

                                                                                                                                                                                                                                              projectTeam?: {
                                                                                                                                                                                                                                              projectNumber?: string;
                                                                                                                                                                                                                                              team?: 'editors' | 'owners' | 'viewers';
                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                property role

                                                                                                                                                                                                                                                role?: 'OWNER' | 'READER' | 'WRITER' | 'FULL_CONTROL';

                                                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                                                  [key: string]: unknown;

                                                                                                                                                                                                                                                    interface AclOptions

                                                                                                                                                                                                                                                    interface AclOptions {}

                                                                                                                                                                                                                                                      property pathPrefix

                                                                                                                                                                                                                                                      pathPrefix: string;

                                                                                                                                                                                                                                                        property request

                                                                                                                                                                                                                                                        request: (
                                                                                                                                                                                                                                                        reqOpts: DecorateRequestOptions,
                                                                                                                                                                                                                                                        callback: BodyResponseCallback
                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                          interface AddAclCallback

                                                                                                                                                                                                                                                          interface AddAclCallback {}

                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                            err: Error | null,
                                                                                                                                                                                                                                                            acl?: AccessControlObject | null,
                                                                                                                                                                                                                                                            apiResponse?: AclMetadata
                                                                                                                                                                                                                                                            ): void;

                                                                                                                                                                                                                                                              interface AddAclOptions

                                                                                                                                                                                                                                                              interface AddAclOptions {}

                                                                                                                                                                                                                                                                property entity

                                                                                                                                                                                                                                                                entity: string;

                                                                                                                                                                                                                                                                  property generation

                                                                                                                                                                                                                                                                  generation?: number;

                                                                                                                                                                                                                                                                    property role

                                                                                                                                                                                                                                                                    role: string;

                                                                                                                                                                                                                                                                      property userProject

                                                                                                                                                                                                                                                                      userProject?: string;

                                                                                                                                                                                                                                                                        interface BucketCallback

                                                                                                                                                                                                                                                                        interface BucketCallback {}

                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                          (err: Error | null, bucket?: Bucket | null, apiResponse?: unknown): void;

                                                                                                                                                                                                                                                                            interface BucketExistsOptions

                                                                                                                                                                                                                                                                            interface BucketExistsOptions extends GetConfig {}

                                                                                                                                                                                                                                                                              property userProject

                                                                                                                                                                                                                                                                              userProject?: string;

                                                                                                                                                                                                                                                                                interface BucketLockCallback

                                                                                                                                                                                                                                                                                interface BucketLockCallback {}

                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                  (err?: Error | null, apiResponse?: unknown): void;

                                                                                                                                                                                                                                                                                    interface BucketMetadata

                                                                                                                                                                                                                                                                                    interface BucketMetadata extends BaseMetadata {}

                                                                                                                                                                                                                                                                                      property acl

                                                                                                                                                                                                                                                                                      acl?: AclMetadata[] | null;

                                                                                                                                                                                                                                                                                        property autoclass

                                                                                                                                                                                                                                                                                        autoclass?: {
                                                                                                                                                                                                                                                                                        enabled?: boolean;
                                                                                                                                                                                                                                                                                        toggleTime?: string;
                                                                                                                                                                                                                                                                                        terminalStorageClass?: string;
                                                                                                                                                                                                                                                                                        terminalStorageClassUpdateTime?: string;
                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                          property billing

                                                                                                                                                                                                                                                                                          billing?: {
                                                                                                                                                                                                                                                                                          requesterPays?: boolean;
                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                            property cors

                                                                                                                                                                                                                                                                                            cors?: Cors[];

                                                                                                                                                                                                                                                                                              property customPlacementConfig

                                                                                                                                                                                                                                                                                              customPlacementConfig?: {
                                                                                                                                                                                                                                                                                              dataLocations?: string[];
                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                property defaultEventBasedHold

                                                                                                                                                                                                                                                                                                defaultEventBasedHold?: boolean;

                                                                                                                                                                                                                                                                                                  property defaultObjectAcl

                                                                                                                                                                                                                                                                                                  defaultObjectAcl?: AclMetadata[];

                                                                                                                                                                                                                                                                                                    property encryption

                                                                                                                                                                                                                                                                                                    encryption?: {
                                                                                                                                                                                                                                                                                                    defaultKmsKeyName?: string;
                                                                                                                                                                                                                                                                                                    } | null;

                                                                                                                                                                                                                                                                                                      property generation

                                                                                                                                                                                                                                                                                                      generation?: string;

                                                                                                                                                                                                                                                                                                        property hardDeleteTime

                                                                                                                                                                                                                                                                                                        hardDeleteTime?: string;

                                                                                                                                                                                                                                                                                                          property hierarchicalNamespace

                                                                                                                                                                                                                                                                                                          hierarchicalNamespace?: {
                                                                                                                                                                                                                                                                                                          enabled?: boolean;
                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                            property iamConfiguration

                                                                                                                                                                                                                                                                                                            iamConfiguration?: {
                                                                                                                                                                                                                                                                                                            publicAccessPrevention?: string;
                                                                                                                                                                                                                                                                                                            uniformBucketLevelAccess?: {
                                                                                                                                                                                                                                                                                                            enabled?: boolean;
                                                                                                                                                                                                                                                                                                            lockedTime?: string;
                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                              property labels

                                                                                                                                                                                                                                                                                                              labels?: {
                                                                                                                                                                                                                                                                                                              [key: string]: string | null;
                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                property lifecycle

                                                                                                                                                                                                                                                                                                                lifecycle?: {
                                                                                                                                                                                                                                                                                                                rule?: LifecycleRule[];
                                                                                                                                                                                                                                                                                                                } | null;

                                                                                                                                                                                                                                                                                                                  property location

                                                                                                                                                                                                                                                                                                                  location?: string;

                                                                                                                                                                                                                                                                                                                    property locationType

                                                                                                                                                                                                                                                                                                                    locationType?: string;

                                                                                                                                                                                                                                                                                                                      property logging

                                                                                                                                                                                                                                                                                                                      logging?: {
                                                                                                                                                                                                                                                                                                                      logBucket?: string;
                                                                                                                                                                                                                                                                                                                      logObjectPrefix?: string;
                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                        property metageneration

                                                                                                                                                                                                                                                                                                                        metageneration?: string;

                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                          name?: string;

                                                                                                                                                                                                                                                                                                                            property objectRetention

                                                                                                                                                                                                                                                                                                                            objectRetention?: {
                                                                                                                                                                                                                                                                                                                            mode?: string;
                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                              property owner

                                                                                                                                                                                                                                                                                                                              owner?: {
                                                                                                                                                                                                                                                                                                                              entity?: string;
                                                                                                                                                                                                                                                                                                                              entityId?: string;
                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                property projectNumber

                                                                                                                                                                                                                                                                                                                                projectNumber?: string | number;

                                                                                                                                                                                                                                                                                                                                  property retentionPolicy

                                                                                                                                                                                                                                                                                                                                  retentionPolicy?: {
                                                                                                                                                                                                                                                                                                                                  effectiveTime?: string;
                                                                                                                                                                                                                                                                                                                                  isLocked?: boolean;
                                                                                                                                                                                                                                                                                                                                  retentionPeriod?: string | number;
                                                                                                                                                                                                                                                                                                                                  } | null;

                                                                                                                                                                                                                                                                                                                                    property rpo

                                                                                                                                                                                                                                                                                                                                    rpo?: string;

                                                                                                                                                                                                                                                                                                                                      property softDeletePolicy

                                                                                                                                                                                                                                                                                                                                      softDeletePolicy?: {
                                                                                                                                                                                                                                                                                                                                      retentionDurationSeconds?: string | number;
                                                                                                                                                                                                                                                                                                                                      readonly effectiveTime?: string;
                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                        property softDeleteTime

                                                                                                                                                                                                                                                                                                                                        softDeleteTime?: string;

                                                                                                                                                                                                                                                                                                                                          property storageClass

                                                                                                                                                                                                                                                                                                                                          storageClass?: string;

                                                                                                                                                                                                                                                                                                                                            property timeCreated

                                                                                                                                                                                                                                                                                                                                            timeCreated?: string;

                                                                                                                                                                                                                                                                                                                                              property updated

                                                                                                                                                                                                                                                                                                                                              updated?: string;

                                                                                                                                                                                                                                                                                                                                                property versioning

                                                                                                                                                                                                                                                                                                                                                versioning?: {
                                                                                                                                                                                                                                                                                                                                                enabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                  property website

                                                                                                                                                                                                                                                                                                                                                  website?: {
                                                                                                                                                                                                                                                                                                                                                  mainPageSuffix?: string;
                                                                                                                                                                                                                                                                                                                                                  notFoundPage?: string;
                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                    interface BucketOptions

                                                                                                                                                                                                                                                                                                                                                    interface BucketOptions {}

                                                                                                                                                                                                                                                                                                                                                      property crc32cGenerator

                                                                                                                                                                                                                                                                                                                                                      crc32cGenerator?: CRC32CValidatorGenerator;

                                                                                                                                                                                                                                                                                                                                                        property generation

                                                                                                                                                                                                                                                                                                                                                        generation?: number;

                                                                                                                                                                                                                                                                                                                                                          property kmsKeyName

                                                                                                                                                                                                                                                                                                                                                          kmsKeyName?: string;

                                                                                                                                                                                                                                                                                                                                                            property preconditionOpts

                                                                                                                                                                                                                                                                                                                                                            preconditionOpts?: PreconditionOptions;

                                                                                                                                                                                                                                                                                                                                                              property softDeleted

                                                                                                                                                                                                                                                                                                                                                              softDeleted?: boolean;

                                                                                                                                                                                                                                                                                                                                                                property userProject

                                                                                                                                                                                                                                                                                                                                                                userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                  interface CombineCallback

                                                                                                                                                                                                                                                                                                                                                                  interface CombineCallback {}

                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                    (err: Error | null, newFile: File | null, apiResponse: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                      interface CombineOptions

                                                                                                                                                                                                                                                                                                                                                                      interface CombineOptions extends PreconditionOptions {}

                                                                                                                                                                                                                                                                                                                                                                        property kmsKeyName

                                                                                                                                                                                                                                                                                                                                                                        kmsKeyName?: string;

                                                                                                                                                                                                                                                                                                                                                                          property userProject

                                                                                                                                                                                                                                                                                                                                                                          userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                            interface CopyCallback

                                                                                                                                                                                                                                                                                                                                                                            interface CopyCallback {}

                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                              (err: Error | null, file?: File | null, apiResponse?: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                interface CopyOptions

                                                                                                                                                                                                                                                                                                                                                                                interface CopyOptions {}

                                                                                                                                                                                                                                                                                                                                                                                  property cacheControl

                                                                                                                                                                                                                                                                                                                                                                                  cacheControl?: string;

                                                                                                                                                                                                                                                                                                                                                                                    property contentDisposition

                                                                                                                                                                                                                                                                                                                                                                                    contentDisposition?: string;

                                                                                                                                                                                                                                                                                                                                                                                      property contentEncoding

                                                                                                                                                                                                                                                                                                                                                                                      contentEncoding?: string;

                                                                                                                                                                                                                                                                                                                                                                                        property contentType

                                                                                                                                                                                                                                                                                                                                                                                        contentType?: string;

                                                                                                                                                                                                                                                                                                                                                                                          property destinationKmsKeyName

                                                                                                                                                                                                                                                                                                                                                                                          destinationKmsKeyName?: string;

                                                                                                                                                                                                                                                                                                                                                                                            property metadata

                                                                                                                                                                                                                                                                                                                                                                                            metadata?: {
                                                                                                                                                                                                                                                                                                                                                                                            [key: string]: string | boolean | number | null;
                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                              property preconditionOpts

                                                                                                                                                                                                                                                                                                                                                                                              preconditionOpts?: PreconditionOptions;

                                                                                                                                                                                                                                                                                                                                                                                                property predefinedAcl

                                                                                                                                                                                                                                                                                                                                                                                                predefinedAcl?: string;

                                                                                                                                                                                                                                                                                                                                                                                                  property token

                                                                                                                                                                                                                                                                                                                                                                                                  token?: string;

                                                                                                                                                                                                                                                                                                                                                                                                    property userProject

                                                                                                                                                                                                                                                                                                                                                                                                    userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                      interface CRC32CValidator

                                                                                                                                                                                                                                                                                                                                                                                                      interface CRC32CValidator {}
                                                                                                                                                                                                                                                                                                                                                                                                      • An interface for CRC32C hashing and validation

                                                                                                                                                                                                                                                                                                                                                                                                      property toString

                                                                                                                                                                                                                                                                                                                                                                                                      toString: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                      • A method returning the CRC32C as a base64-encoded string.

                                                                                                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                                                                                                        Hashing the string 'data' should return 'rth90Q=='

                                                                                                                                                                                                                                                                                                                                                                                                        const buffer = Buffer.from('data');
                                                                                                                                                                                                                                                                                                                                                                                                        crc32c.update(buffer);
                                                                                                                                                                                                                                                                                                                                                                                                        crc32c.toString(); // 'rth90Q=='

                                                                                                                                                                                                                                                                                                                                                                                                      property update

                                                                                                                                                                                                                                                                                                                                                                                                      update: (data: Buffer) => void;
                                                                                                                                                                                                                                                                                                                                                                                                      • A method for passing Buffers for CRC32C generation.

                                                                                                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                                                                                                        Hashing buffers from 'some ' and 'text\n'

                                                                                                                                                                                                                                                                                                                                                                                                        const buffer1 = Buffer.from('some ');
                                                                                                                                                                                                                                                                                                                                                                                                        crc32c.update(buffer1);
                                                                                                                                                                                                                                                                                                                                                                                                        const buffer2 = Buffer.from('text\n');
                                                                                                                                                                                                                                                                                                                                                                                                        crc32c.update(buffer2);
                                                                                                                                                                                                                                                                                                                                                                                                        crc32c.toString(); // 'DkjKuA=='

                                                                                                                                                                                                                                                                                                                                                                                                      property validate

                                                                                                                                                                                                                                                                                                                                                                                                      validate: (value: string) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                      • A method validating a base64-encoded CRC32C string.

                                                                                                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                                                                                                        Should return true if the value matches, false otherwise

                                                                                                                                                                                                                                                                                                                                                                                                        const buffer = Buffer.from('data');
                                                                                                                                                                                                                                                                                                                                                                                                        crc32c.update(buffer);
                                                                                                                                                                                                                                                                                                                                                                                                        crc32c.validate('DkjKuA=='); // false
                                                                                                                                                                                                                                                                                                                                                                                                        crc32c.validate('rth90Q=='); // true

                                                                                                                                                                                                                                                                                                                                                                                                      interface CRC32CValidatorGenerator

                                                                                                                                                                                                                                                                                                                                                                                                      interface CRC32CValidatorGenerator {}
                                                                                                                                                                                                                                                                                                                                                                                                      • A function that generates a CRC32C Validator

                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                      (): CRC32CValidator;
                                                                                                                                                                                                                                                                                                                                                                                                      • Should return a new, ready-to-use CRC32CValidator

                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateBucketQuery

                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateBucketQuery {}

                                                                                                                                                                                                                                                                                                                                                                                                        property enableObjectRetention

                                                                                                                                                                                                                                                                                                                                                                                                        enableObjectRetention: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                          property predefinedAcl

                                                                                                                                                                                                                                                                                                                                                                                                          predefinedAcl?:
                                                                                                                                                                                                                                                                                                                                                                                                          | 'authenticatedRead'
                                                                                                                                                                                                                                                                                                                                                                                                          | 'private'
                                                                                                                                                                                                                                                                                                                                                                                                          | 'projectPrivate'
                                                                                                                                                                                                                                                                                                                                                                                                          | 'publicRead'
                                                                                                                                                                                                                                                                                                                                                                                                          | 'publicReadWrite';

                                                                                                                                                                                                                                                                                                                                                                                                            property predefinedDefaultObjectAcl

                                                                                                                                                                                                                                                                                                                                                                                                            predefinedDefaultObjectAcl?:
                                                                                                                                                                                                                                                                                                                                                                                                            | 'authenticatedRead'
                                                                                                                                                                                                                                                                                                                                                                                                            | 'bucketOwnerFullControl'
                                                                                                                                                                                                                                                                                                                                                                                                            | 'bucketOwnerRead'
                                                                                                                                                                                                                                                                                                                                                                                                            | 'private'
                                                                                                                                                                                                                                                                                                                                                                                                            | 'projectPrivate'
                                                                                                                                                                                                                                                                                                                                                                                                            | 'publicRead';

                                                                                                                                                                                                                                                                                                                                                                                                              property project

                                                                                                                                                                                                                                                                                                                                                                                                              project: string;

                                                                                                                                                                                                                                                                                                                                                                                                                property projection

                                                                                                                                                                                                                                                                                                                                                                                                                projection?: 'full' | 'noAcl';

                                                                                                                                                                                                                                                                                                                                                                                                                  property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                  userProject: string;

                                                                                                                                                                                                                                                                                                                                                                                                                    interface CreateBucketRequest

                                                                                                                                                                                                                                                                                                                                                                                                                    interface CreateBucketRequest extends BucketMetadata {}

                                                                                                                                                                                                                                                                                                                                                                                                                      property archive

                                                                                                                                                                                                                                                                                                                                                                                                                      archive?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                        property coldline

                                                                                                                                                                                                                                                                                                                                                                                                                        coldline?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                          property dataLocations

                                                                                                                                                                                                                                                                                                                                                                                                                          dataLocations?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                            property dra

                                                                                                                                                                                                                                                                                                                                                                                                                            dra?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                              property enableObjectRetention

                                                                                                                                                                                                                                                                                                                                                                                                                              enableObjectRetention?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                property multiRegional

                                                                                                                                                                                                                                                                                                                                                                                                                                multiRegional?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property nearline

                                                                                                                                                                                                                                                                                                                                                                                                                                  nearline?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property predefinedAcl

                                                                                                                                                                                                                                                                                                                                                                                                                                    predefinedAcl?:
                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'authenticatedRead'
                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'private'
                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'projectPrivate'
                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'publicRead'
                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'publicReadWrite';

                                                                                                                                                                                                                                                                                                                                                                                                                                      property predefinedDefaultObjectAcl

                                                                                                                                                                                                                                                                                                                                                                                                                                      predefinedDefaultObjectAcl?:
                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'authenticatedRead'
                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'bucketOwnerFullControl'
                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'bucketOwnerRead'
                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'private'
                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'projectPrivate'
                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'publicRead';

                                                                                                                                                                                                                                                                                                                                                                                                                                        property projection

                                                                                                                                                                                                                                                                                                                                                                                                                                        projection?: 'full' | 'noAcl';

                                                                                                                                                                                                                                                                                                                                                                                                                                          property regional

                                                                                                                                                                                                                                                                                                                                                                                                                                          regional?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property requesterPays

                                                                                                                                                                                                                                                                                                                                                                                                                                            requesterPays?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property rpo

                                                                                                                                                                                                                                                                                                                                                                                                                                              rpo?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property standard

                                                                                                                                                                                                                                                                                                                                                                                                                                                standard?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property storageClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                  storageClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                    userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property versioning

                                                                                                                                                                                                                                                                                                                                                                                                                                                      versioning?: Versioning;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CreateChannelCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CreateChannelCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                          (err: Error | null, channel: Channel | null, apiResponse: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CreateChannelConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CreateChannelConfig extends WatchAllOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property address

                                                                                                                                                                                                                                                                                                                                                                                                                                                              address: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CreateChannelOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CreateChannelOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CreateHmacKeyCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CreateHmacKeyCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      err: Error | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hmacKey?: HmacKey | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      secret?: string | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      apiResponse?: HmacKeyResourceResponse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CreateHmacKeyOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CreateHmacKeyOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property projectId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          projectId?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CreateNotificationCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CreateNotificationCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                err: Error | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                notification: Notification | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                apiResponse: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CreateNotificationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CreateNotificationOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property customAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    customAttributes?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [key: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property eventTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      eventTypes?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property objectNamePrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        objectNamePrefix?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property payloadFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          payloadFormat?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CreateReadStreamOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CreateReadStreamOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property [GCCL_GCS_CMD_KEY]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [GCCL_GCS_CMD_KEY]?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property decompress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  decompress?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property end

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    end?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      start?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property validation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          validation?: 'md5' | 'crc32c' | false | true;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CreateResumableUploadCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CreateResumableUploadCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (err: Error | null, uri?: string): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CreateResumableUploadOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CreateResumableUploadOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                extends Pick<resumableUpload.UploadConfig, PublicResumableUploadOptions> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property [GCCL_GCS_CMD_KEY]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [GCCL_GCS_CMD_KEY]?: resumableUpload.UploadConfig[typeof GCCL_GCS_CMD_KEY];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property preconditionOpts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    preconditionOpts?: PreconditionOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property resumeCRC32C

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resumeCRC32C?: Parameters<(typeof CRC32C)['from']>[0];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • A CRC32C to resume from when continuing a previous upload. It is recommended to capture the crc32c event from previous upload sessions to provide in subsequent requests in order to accurately track the upload. This is **required** when validating a final portion of the uploaded object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateWriteStreamOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateWriteStreamOptions extends CreateResumableUploadOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property contentType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        contentType?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property gzip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          gzip?: string | boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property resumable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            resumable?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              timeout?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property validation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                validation?: string | boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface DeleteBucketCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface DeleteBucketCallback extends DeleteCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (err: Error | null, apiResponse: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DeleteBucketOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DeleteBucketOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ignoreNotFound

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ignoreNotFound?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DeleteFileCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DeleteFileCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (err: Error | null, apiResponse?: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DeleteFileOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DeleteFileOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ignoreNotFound

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ignoreNotFound?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DeleteFilesCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DeleteFilesCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (err: Error | Error[] | null, apiResponse?: object): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DeleteFilesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DeleteFilesOptions extends GetFilesOptions, PreconditionOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property force

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            force?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface DeleteNotificationCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface DeleteNotificationCallback {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • DeleteNotificationCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter err

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Request error, if any.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter apiResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The full API response.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (err: Error | null, apiResponse?: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DeleteNotificationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DeleteNotificationOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DisableRequesterPaysCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DisableRequesterPaysCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (err?: Error | null, apiResponse?: object): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface DownloadFileInChunksOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface DownloadFileInChunksOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property chunkSizeBytes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          chunkSizeBytes?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property concurrencyLimit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            concurrencyLimit?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property destination

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              destination?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property noReturnData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                noReturnData?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property validation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  validation?: 'crc32c' | false;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DownloadManyFilesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DownloadManyFilesOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property concurrencyLimit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      concurrencyLimit?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property passthroughOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        passthroughOptions?: DownloadOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property prefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          prefix?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property skipIfExists

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            skipIfExists?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property stripPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              stripPrefix?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DownloadOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DownloadOptions extends CreateReadStreamOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property destination

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  destination?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EnableRequesterPaysCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EnableRequesterPaysCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (err?: Error | null, apiResponse?: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface EncryptionKeyOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface EncryptionKeyOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property encryptionKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          encryptionKey?: string | Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property kmsKeyName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            kmsKeyName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property preconditionOpts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              preconditionOpts?: PreconditionOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface FileExistsCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface FileExistsCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (err: Error | null, exists?: boolean): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface FileExistsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface FileExistsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface FileMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface FileMetadata extends BaseMetadata {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property acl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          acl?: AclMetadata[] | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property bucket

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bucket?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cacheControl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cacheControl?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property componentCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                componentCount?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property contentDisposition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  contentDisposition?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property contentEncoding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    contentEncoding?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property contentLanguage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      contentLanguage?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property contentType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        contentType?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property crc32c

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          crc32c?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property customerEncryption

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            customerEncryption?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            encryptionAlgorithm?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            keySha256?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property customTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              customTime?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property eventBasedHold

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                eventBasedHold?: boolean | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property eventBasedHoldReleaseTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly eventBasedHoldReleaseTime?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property generation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    generation?: string | number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property hardDeleteTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hardDeleteTime?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property kmsKeyName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        kmsKeyName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property md5Hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          md5Hash?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            mediaLink?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              metadata?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [key: string]: string | boolean | number | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property metageneration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                metageneration?: string | number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property owner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    owner?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    entity?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    entityId?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property restoreToken

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      restoreToken?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property retention

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        retention?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        retainUntilTime?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        mode?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property retentionExpirationTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          retentionExpirationTime?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            size?: string | number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property softDeleteTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              softDeleteTime?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property storageClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                storageClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property temporaryHold

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  temporaryHold?: boolean | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property timeCreated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeCreated?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property timeDeleted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      timeDeleted?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeStorageClassUpdated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        timeStorageClassUpdated?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property updated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          updated?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface FileOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface FileOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property crc32cGenerator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              crc32cGenerator?: CRC32CValidatorGenerator;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property encryptionKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                encryptionKey?: string | Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property generation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  generation?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property kmsKeyName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    kmsKeyName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property preconditionOpts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      preconditionOpts?: PreconditionOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property restoreToken

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        restoreToken?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GenerateSignedPostPolicyV2Callback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GenerateSignedPostPolicyV2Callback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (err: Error | null, policy?: PolicyDocument): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GenerateSignedPostPolicyV2Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GenerateSignedPostPolicyV2Options {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property acl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  acl?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property contentLengthRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    contentLengthRange?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    min?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    max?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property equals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      equals?: string[] | string[][];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property expires

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        expires: string | number | Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property signingEndpoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          signingEndpoint?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property startsWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          startsWith?: string[] | string[][];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property successRedirect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            successRedirect?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property successStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              successStatus?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GenerateSignedPostPolicyV4Callback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GenerateSignedPostPolicyV4Callback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (err: Error | null, output?: SignedPostPolicyV4Output): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GenerateSignedPostPolicyV4Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GenerateSignedPostPolicyV4Options {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property bucketBoundHostname

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bucketBoundHostname?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property conditions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        conditions?: object[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property expires

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          expires: string | number | Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property fields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fields?: PolicyFields;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property signingEndpoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              signingEndpoint?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property virtualHostedStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              virtualHostedStyle?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetAclCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetAclCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  err: Error | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  acl?: AccessControlObject | AccessControlObject[] | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  apiResponse?: AclMetadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetAclOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetAclOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property entity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      entity: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property generation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        generation?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetBucketCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetBucketCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (err: ApiError | null, bucket: Bucket | null, apiResponse: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetBucketMetadataCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetBucketMetadataCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  err: ApiError | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  metadata: BucketMetadata | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  apiResponse: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetBucketMetadataOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetBucketMetadataOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetBucketOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetBucketOptions extends GetConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetBucketsCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetBucketsCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              err: Error | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              buckets: Bucket[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nextQuery?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              apiResponse?: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetBucketSignedUrlConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetBucketSignedUrlConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                extends Pick<SignerGetSignedUrlConfig, 'host' | 'signingEndpoint'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property action

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  action: 'list';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property cname

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cname?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property expires

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      expires: string | number | Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property extensionHeaders

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        extensionHeaders?: http.OutgoingHttpHeaders;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property queryParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          queryParams?: Query;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            version?: 'v2' | 'v4';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property virtualHostedStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              virtualHostedStyle?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetBucketsRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetBucketsRequest {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property autoPaginate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  autoPaginate?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property generation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    generation?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property maxApiCalls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      maxApiCalls?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property maxResults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        maxResults?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property pageToken

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pageToken?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property prefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            prefix?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property project

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              project?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property softDeleted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                softDeleted?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetExpirationDateCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetExpirationDateCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (err: Error | null, expirationDate?: Date | null, apiResponse?: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetFileCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetFileCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (err: Error | null, file?: File, apiResponse?: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetFileMetadataCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetFileMetadataCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (err: Error | null, metadata?: FileMetadata, apiResponse?: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetFileMetadataOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetFileMetadataOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetFileOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetFileOptions extends GetConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property generation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      generation?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property restoreToken

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        restoreToken?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property softDeleted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          softDeleted?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetFilesCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetFilesCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (err: Error | null, files?: File[], nextQuery?: {}, apiResponse?: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetFilesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetFilesOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property autoPaginate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    autoPaginate?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property delimiter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      delimiter?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property endOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        endOffset?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property fields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fields?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property includeFoldersAsPrefixes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            includeFoldersAsPrefixes?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property includeTrailingDelimiter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              includeTrailingDelimiter?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property matchGlob

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                matchGlob?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property maxApiCalls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  maxApiCalls?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property maxResults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    maxResults?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property pageToken

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pageToken?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property prefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        prefix?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property softDeleted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          softDeleted?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property startOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            startOffset?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property versions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                versions?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetHmacKeysCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetHmacKeysCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    err: Error | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hmacKeys: HmacKey[] | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nextQuery?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    apiResponse?: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetHmacKeysOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetHmacKeysOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property autoPaginate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        autoPaginate?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property maxApiCalls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          maxApiCalls?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property maxResults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            maxResults?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property pageToken

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pageToken?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property projectId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                projectId?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property serviceAccountEmail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  serviceAccountEmail?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property showDeletedKeys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    showDeletedKeys?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetLabelsCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetLabelsCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (err: Error | null, labels: object | null): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetLabelsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GetLabelsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetNotificationCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetNotificationCallback {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • GetNotificationCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter err

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Request error, if any.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter notification

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The Notification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter apiResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The full API response.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                err: Error | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                notification?: Notification | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                apiResponse?: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetNotificationMetadataCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetNotificationMetadataCallback {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • GetNotificationMetadataCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter err

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Request error, if any.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter files

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The notification metadata.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter apiResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The full API response.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (err: Error | null, metadata?: ResponseBody, apiResponse?: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetNotificationMetadataOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetNotificationMetadataOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetNotificationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetNotificationOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property autoCreate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          autoCreate?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Automatically create the object if it does not exist. Default: false.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          userProject?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • The ID of the project which will be billed for the request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetNotificationsCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetNotificationsCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            err: Error | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            notifications: Notification[] | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            apiResponse: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetNotificationsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetNotificationsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetPolicyCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetPolicyCallback {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • GetPolicyCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter err

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Request error, if any.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter acl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The policy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter apiResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The full API response.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (err?: Error | null, acl?: Policy, apiResponse?: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetPolicyOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetPolicyOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property requestedPolicyVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      requestedPolicyVersion?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetServiceAccountCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetServiceAccountCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            err: Error | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            serviceAccount?: ServiceAccount,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            apiResponse?: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetServiceAccountOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetServiceAccountOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property projectIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                projectIdentifier?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSignedUrlCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GetSignedUrlCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (err: Error | null, url?: string): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetSignedUrlConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GetSignedUrlConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        extends Pick<SignerGetSignedUrlConfig, 'host' | 'signingEndpoint'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property accessibleAt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          accessibleAt?: string | number | Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property action

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            action: 'read' | 'write' | 'delete' | 'resumable';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cname

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cname?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property contentMd5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                contentMd5?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property contentType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  contentType?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property expires

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    expires: string | number | Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property extensionHeaders

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      extensionHeaders?: http.OutgoingHttpHeaders;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property promptSaveAs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        promptSaveAs?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property queryParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          queryParams?: Query;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property responseDisposition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            responseDisposition?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property responseType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              responseType?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                version?: 'v2' | 'v4';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property virtualHostedStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  virtualHostedStyle?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface HashStreamValidatorOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface HashStreamValidatorOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property crc32c

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      crc32c: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Enables CRC32C calculation. To validate a provided value use crc32cExpected.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property crc32cExpected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      crc32cExpected?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Sets the expected CRC32C value to verify once all data has been consumed. Also sets the crc32c option to true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property crc32cGenerator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      crc32cGenerator: CRC32CValidatorGenerator;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Set a custom CRC32C generator. Used if crc32cInstance has not been provided.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property crc32cInstance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      crc32cInstance: CRC32CValidator;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • A CRC32C instance for validation. To validate a provided value use crc32cExpected.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property md5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      md5: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Enables MD5 calculation. To validate a provided value use md5Expected.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property md5Expected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      md5Expected?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Sets the expected MD5 value to verify once all data has been consumed. Also sets the md5 option to true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property updateHashesOnly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      updateHashesOnly?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Indicates whether or not to run a validation check or only update the hash values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface HmacKeyMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface HmacKeyMetadata extends BaseMetadata {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property accessId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        accessId?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property etag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          etag?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property projectId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            projectId?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property serviceAccountEmail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              serviceAccountEmail?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                state?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property timeCreated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  timeCreated?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property updated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    updated?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface HmacKeyMetadataCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface HmacKeyMetadataCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (err: Error | null, metadata?: HmacKeyMetadata, apiResponse?: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface HmacKeyResourceResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface HmacKeyResourceResponse {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            metadata: HmacKeyMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property secret

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              secret: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Labels

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Labels {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [key: string]: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface LifecycleAction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface LifecycleAction {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property storageClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      storageClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'Delete' | 'SetStorageClass' | 'AbortIncompleteMultipartUpload';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface LifecycleCondition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface LifecycleCondition {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property age

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            age?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property createdBefore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              createdBefore?: Date | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property customTimeBefore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                customTimeBefore?: Date | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property daysSinceCustomTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  daysSinceCustomTime?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property daysSinceNoncurrentTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    daysSinceNoncurrentTime?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property isLive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isLive?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property matchesPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        matchesPrefix?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property matchesStorageClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          matchesStorageClass?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property matchesSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            matchesSuffix?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property noncurrentTimeBefore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              noncurrentTimeBefore?: Date | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property numNewerVersions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                numNewerVersions?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface LifecycleCondition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface LifecycleCondition {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property age

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    age?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property createdBefore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createdBefore?: Date | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property customTimeBefore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        customTimeBefore?: Date | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property daysSinceCustomTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          daysSinceCustomTime?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property daysSinceNoncurrentTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            daysSinceNoncurrentTime?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isLive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isLive?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property matchesPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                matchesPrefix?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property matchesStorageClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  matchesStorageClass?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property matchesSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    matchesSuffix?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property noncurrentTimeBefore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      noncurrentTimeBefore?: Date | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property numNewerVersions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        numNewerVersions?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface LifecycleRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface LifecycleRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property action

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            action: LifecycleAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property condition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              condition: LifecycleCondition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface LifecycleRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface LifecycleRule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property action

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  action: LifecycleAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property condition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    condition: LifecycleCondition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MakeBucketPrivateCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MakeBucketPrivateCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (err?: Error | null, files?: File[]): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MakeBucketPrivateOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MakeBucketPrivateOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property force

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            force?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property includeFiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              includeFiles?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                metadata?: BucketMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property preconditionOpts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  preconditionOpts?: PreconditionOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MakeBucketPublicCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MakeBucketPublicCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (err?: Error | null, files?: File[]): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MakeBucketPublicOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MakeBucketPublicOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property force

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            force?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property includeFiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              includeFiles?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MakeFilePrivateOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MakeFilePrivateOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  metadata?: FileMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property preconditionOpts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    preconditionOpts?: PreconditionOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property strict

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      strict?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MakeFilePublicCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MakeFilePublicCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (err?: Error | null, apiResponse?: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MoveCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MoveCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (err: Error | null, destinationFile?: File | null, apiResponse?: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MoveOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MoveOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property preconditionOpts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    preconditionOpts?: PreconditionOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MultiPartUploadHelper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MultiPartUploadHelper {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property bucket

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bucket: Bucket;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property fileName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fileName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property partsMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              partsMap?: Map<number, string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property uploadId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                uploadId?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method abortUpload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  abortUpload: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method completeUpload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    completeUpload: () => Promise<GaxiosResponse | undefined>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method initiateUpload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      initiateUpload: (headers?: { [key: string]: string }) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method uploadPart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        uploadPart: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        partNumber: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        chunk: Buffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        validation?: 'md5' | false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface NotificationMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface NotificationMetadata extends BaseMetadata {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property custom_attributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            custom_attributes?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [key: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property event_types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              event_types?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property object_name_prefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                object_name_prefix?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property payload_format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  payload_format?: 'JSON_API_V1' | 'NONE';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property topic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    topic?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Policy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Policy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property bindings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bindings: PolicyBinding[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property etag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          etag?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            version?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PolicyDocument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PolicyDocument {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property base64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                base64: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  signature: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    string: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PolicyFields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PolicyFields {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PreconditionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PreconditionOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ifGenerationMatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ifGenerationMatch?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ifGenerationNotMatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ifGenerationNotMatch?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ifMetagenerationMatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ifMetagenerationMatch?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ifMetagenerationNotMatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ifMetagenerationNotMatch?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RemoveAclCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RemoveAclCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (err: Error | null, apiResponse?: AclMetadata): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RemoveAclOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RemoveAclOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property entity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          entity: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property generation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            generation?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SaveCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SaveCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (err?: Error | null): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SaveOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SaveOptions extends CreateWriteStreamOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onUploadProgress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onUploadProgress?: (progressEvent: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ServiceAccount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ServiceAccount {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property emailAddress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          emailAddress?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SetBucketMetadataCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SetBucketMetadataCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (err?: Error | null, metadata?: BucketMetadata): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SetBucketMetadataOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SetBucketMetadataOptions extends PreconditionOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SetBucketStorageClassCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SetBucketStorageClassCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (err?: Error | null): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SetBucketStorageClassOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SetBucketStorageClassOptions extends PreconditionOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SetFileMetadataCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SetFileMetadataCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (err?: Error | null, apiResponse?: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SetFileMetadataOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SetFileMetadataOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SetHmacKeyMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SetHmacKeyMetadata {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property etag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      etag?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        state?: 'ACTIVE' | 'INACTIVE';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SetHmacKeyMetadataOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SetHmacKeyMetadataOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            userProject?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • This parameter is currently ignored.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SetLabelsCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SetLabelsCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (err?: Error | null, metadata?: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SetLabelsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SetLabelsOptions extends PreconditionOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SetPolicyCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SetPolicyCallback {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • SetPolicyCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter err

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Request error, if any.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter acl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The policy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter apiResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The full API response.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (err?: Error | null, acl?: Policy, apiResponse?: object): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SetPolicyOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SetPolicyOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • {object} SetPolicyOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The ID of the project which will be billed for the request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SetStorageClassCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SetStorageClassCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (err?: Error | null, apiResponse?: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SetStorageClassOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SetStorageClassOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property preconditionOpts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              preconditionOpts?: PreconditionOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SignedPostPolicyV4Output

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SignedPostPolicyV4Output {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property fields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fields: PolicyFields;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      url: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface StopCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface StopCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (err: Error | null, apiResponse?: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface StorageOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface StorageOptions extends ServiceOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property apiEndpoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              apiEndpoint?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • The API endpoint of the service used to make requests. Defaults to storage.googleapis.com.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property crc32cGenerator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              crc32cGenerator?: CRC32CValidatorGenerator;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property retryOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                retryOptions?: RetryOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface TestIamPermissionsCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface TestIamPermissionsCallback {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • TestIamPermissionsCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter err

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Request error, if any.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter acl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A subset of permissions that the caller is allowed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter apiResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The full API response.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  err?: Error | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  acl?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [key: string]: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  } | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  apiResponse?: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TestIamPermissionsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TestIamPermissionsOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {object} TestIamPermissionsOptions Configuration options for Iam#testPermissions().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The ID of the project which will be billed for the request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface UpdateAclCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface UpdateAclCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        err: Error | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        acl?: AccessControlObject | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        apiResponse?: AclMetadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface UpdateAclOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface UpdateAclOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property entity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            entity: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property generation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              generation?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property role

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                role: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface UploadCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface UploadCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (err: Error | null, file?: File | null, apiResponse?: unknown): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UploadFileInChunksOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UploadFileInChunksOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property autoAbortFailure

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          autoAbortFailure?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property chunkSizeBytes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            chunkSizeBytes?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property concurrencyLimit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              concurrencyLimit?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property headers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                headers?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property maxQueueSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  maxQueueSize?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property partsMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    partsMap?: Map<number, string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property uploadId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      uploadId?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property uploadName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        uploadName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property validation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          validation?: 'md5' | false;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface UploadManyFilesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface UploadManyFilesOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property concurrencyLimit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              concurrencyLimit?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property passthroughOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                passthroughOptions?: Omit<UploadOptions, 'destination'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property prefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  prefix?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property skipIfExists

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    skipIfExists?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method customDestinationBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      customDestinationBuilder: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      path: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: UploadManyFilesOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UploadOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UploadOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        extends CreateResumableUploadOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CreateWriteStreamOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property destination

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          destination?: string | File;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property encryptionKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            encryptionKey?: string | Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property kmsKeyName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              kmsKeyName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onUploadProgress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onUploadProgress?: (progressEvent: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enums

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enum IdempotencyStrategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enum IdempotencyStrategy {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  RetryAlways = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  RetryConditional = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  RetryNever = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member RetryAlways

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RetryAlways = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member RetryConditional

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      RetryConditional = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member RetryNever

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        RetryNever = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type AddAclResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type AddAclResponse = [AccessControlObject, AclMetadata];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type BucketExistsCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type BucketExistsCallback = ExistsCallback;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type BucketExistsResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type BucketExistsResponse = [boolean];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type BucketLockResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type BucketLockResponse = [unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CombineResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CombineResponse = [File, unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CopyResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CopyResponse = [File, unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateBucketResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateBucketResponse = [Bucket, unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreateChannelResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreateChannelResponse = [Channel, unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateHmacKeyResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateHmacKeyResponse = [HmacKey, string, HmacKeyResourceResponse];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreateNotificationResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreateNotificationResponse = [Notification, unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CreateResumableUploadResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CreateResumableUploadResponse = [string];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DeleteBucketResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DeleteBucketResponse = [unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteFileResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteFileResponse = [unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DeleteLabelsCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DeleteLabelsCallback = SetLabelsCallback;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DeleteLabelsResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DeleteLabelsResponse = [unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DisableRequesterPaysResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DisableRequesterPaysResponse = [unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DownloadCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DownloadCallback = (err: RequestError | null, contents: Buffer) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DownloadResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DownloadResponse = [Buffer];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type EnableRequesterPaysResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type EnableRequesterPaysResponse = [unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FileExistsResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FileExistsResponse = [boolean];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type GenerateSignedPostPolicyV2Response

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type GenerateSignedPostPolicyV2Response = [PolicyDocument];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type GenerateSignedPostPolicyV4Response

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type GenerateSignedPostPolicyV4Response = [SignedPostPolicyV4Output];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type GetAclResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type GetAclResponse = [AccessControlObject | AccessControlObject[], AclMetadata];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type GetBucketMetadataResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type GetBucketMetadataResponse = [BucketMetadata, unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GetBucketResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GetBucketResponse = [Bucket, unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type GetBucketsResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type GetBucketsResponse = [Bucket[], {}, unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GetExpirationDateResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GetExpirationDateResponse = [Date];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type GetFileMetadataResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type GetFileMetadataResponse = [FileMetadata, unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type GetFileResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type GetFileResponse = [File, unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type GetFilesResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type GetFilesResponse = [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    File[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (GetFilesOptions | {}) & Partial<Pick<GetFilesOptions, 'pageToken'>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type GetHmacKeysResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type GetHmacKeysResponse = [HmacKey[]];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type GetLabelsResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type GetLabelsResponse = [unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GetNotificationMetadataResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GetNotificationMetadataResponse = [ResponseBody, unknown];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • {array} GetNotificationMetadataResponse {object} 0 The notification metadata. {object} 1 The full API response.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GetNotificationResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GetNotificationResponse = [Notification, unknown];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • {array} GetNotificationResponse {Notification} 0 The Notification {object} 1 The full API response.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GetNotificationsResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type GetNotificationsResponse = [Notification[], unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type GetPolicyResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type GetPolicyResponse = [Policy, unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GetServiceAccountResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GetServiceAccountResponse = [ServiceAccount, unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type GetSignedUrlResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type GetSignedUrlResponse = [SignerGetSignedUrlResponse];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type HmacKeyMetadataResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type HmacKeyMetadataResponse = [HmacKeyMetadata, unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MakeBucketPrivateResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MakeBucketPrivateResponse = [File[]];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MakeBucketPublicResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MakeBucketPublicResponse = [File[]];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type MakeFilePrivateCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type MakeFilePrivateCallback = SetFileMetadataCallback;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MakeFilePrivateResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MakeFilePrivateResponse = [unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type MakeFilePublicResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type MakeFilePublicResponse = [unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MoveFileAtomicCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MoveFileAtomicCallback = MoveCallback;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MoveFileAtomicOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MoveFileAtomicOptions = MoveOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MoveFileAtomicResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MoveFileAtomicResponse = MoveResponse;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MoveResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MoveResponse = [unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MultiPartHelperGenerator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MultiPartHelperGenerator = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bucket: Bucket,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fileName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      uploadId?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      partsMap?: Map<number, string>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => MultiPartUploadHelper;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type PredefinedAcl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type PredefinedAcl =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'authenticatedRead'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'bucketOwnerFullControl'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'bucketOwnerRead'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'private'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'projectPrivate'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'publicRead';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type RemoveAclResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type RemoveAclResponse = [AclMetadata];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RotateEncryptionKeyCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RotateEncryptionKeyCallback = CopyCallback;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RotateEncryptionKeyOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RotateEncryptionKeyOptions = string | Buffer | EncryptionKeyOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type RotateEncryptionKeyResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type RotateEncryptionKeyResponse = CopyResponse;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SaveData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SaveData =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Buffer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | PipelineSource<string | Buffer | Uint8Array>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SetBucketMetadataResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SetBucketMetadataResponse = [BucketMetadata];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SetFileMetadataResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SetFileMetadataResponse = [unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SetLabelsResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SetLabelsResponse = [unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SetPolicyResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SetPolicyResponse = [Policy, unknown];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • {array} SetPolicyResponse {object} 0 The policy. {object} 1 The full API response.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SetStorageClassResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SetStorageClassResponse = [unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TestIamPermissionsResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TestIamPermissionsResponse = [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [key: string]: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • {array} TestIamPermissionsResponse {object} 0 A subset of permissions that the caller is allowed. {object} 1 The full API response.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type UpdateAclResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type UpdateAclResponse = [AccessControlObject, AclMetadata];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type UploadResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type UploadResponse = [File, unknown];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Package Files (14)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dependencies (15)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dev Dependencies (38)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@google-cloud/storage.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@google-cloud/storage)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <a href="https://www.jsdocs.io/package/@google-cloud/storage"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>