@google-cloud/storage

  • Version 6.5.2
  • Published
  • 805 kB
  • 18 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

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: Int32Array;

        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

        Classes

        class Bucket

        class Bucket extends ServiceObject {}
        • 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 metadata

                  metadata: any;

                    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<[ResponseBody, Metadata]>;
                                                                  (reqOpts: DecorateRequestOptions, callback: BodyResponseCallback): void;
                                                                  };

                                                                    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: Metadata,
                                                                        options?: SetMetadataOptions
                                                                        ): Promise<SetMetadataResponse>;
                                                                        (metadata: any, callback: MetadataCallback): void;
                                                                        (metadata: any, options: object, callback: MetadataCallback): 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 {}
                                                                                • 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<Metadata>; (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: Int32Array;

                                                                                        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.

                                                                                            Parameter value

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

                                                                                          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> {}

                                                                                          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 metadata

                                                                                                      metadata: any;

                                                                                                        property name

                                                                                                        name: string;

                                                                                                          property parent

                                                                                                          parent: Bucket;

                                                                                                            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 | File | Bucket, callback: CopyCallback): void;
                                                                                                                  (
                                                                                                                  destination: string | File | Bucket,
                                                                                                                  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 Upload Options (Simple or Resumable) See Objects: insert API Documentation

                                                                                                                        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.
                                                                                                                        });

                                                                                                                      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 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 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 | File | Bucket, callback: MoveCallback): void;
                                                                                                                                        (
                                                                                                                                        destination: string | File | Bucket,
                                                                                                                                        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<[ResponseBody, Metadata]>;
                                                                                                                                            (reqOpts: DecorateRequestOptions, callback: BodyResponseCallback): void;
                                                                                                                                            };

                                                                                                                                              method rotateEncryptionKey

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

                                                                                                                                                method save

                                                                                                                                                save: {
                                                                                                                                                (data: string | Buffer, 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: Metadata,
                                                                                                                                                  options?: SetMetadataOptions
                                                                                                                                                  ): Promise<SetMetadataResponse>;
                                                                                                                                                  (metadata: any, callback: MetadataCallback): void;
                                                                                                                                                  (metadata: any, options: object, callback: MetadataCallback): 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 crc32cEnabled

                                                                                                                                                          readonly crc32cEnabled: boolean;

                                                                                                                                                            property md5Enabled

                                                                                                                                                            readonly md5Enabled: boolean;

                                                                                                                                                              method test

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

                                                                                                                                                                class HmacKey

                                                                                                                                                                class HmacKey extends ServiceObject<HmacKeyMetadata | undefined> {}

                                                                                                                                                                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 metadata

                                                                                                                                                                metadata: HmacKeyMetadata;

                                                                                                                                                                  property storage

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

                                                                                                                                                                  method setMetadata

                                                                                                                                                                  setMetadata: {
                                                                                                                                                                  (
                                                                                                                                                                  metadata: Metadata,
                                                                                                                                                                  options?: SetMetadataOptions
                                                                                                                                                                  ): Promise<SetMetadataResponse>;
                                                                                                                                                                  (metadata: any, callback: MetadataCallback): void;
                                                                                                                                                                  (metadata: any, options: object, callback: MetadataCallback): 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 Notification

                                                                                                                                                                          class Notification extends ServiceObject {}
                                                                                                                                                                          • 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);

                                                                                                                                                                            method delete

                                                                                                                                                                            delete: {
                                                                                                                                                                            (options?: DeleteNotificationOptions): Promise<[Metadata]>;
                                                                                                                                                                            (
                                                                                                                                                                            options: DeleteNotificationOptions,
                                                                                                                                                                            callback: DeleteNotificationCallback
                                                                                                                                                                            ): void;
                                                                                                                                                                            (callback: DeleteNotificationCallback): void;
                                                                                                                                                                            };

                                                                                                                                                                              method get

                                                                                                                                                                              get: {
                                                                                                                                                                              (options?: GetNotificationOptions): Promise<GetNotificationResponse>;
                                                                                                                                                                              (options: GetNotificationOptions, callback: GetNotificationCallback): void;
                                                                                                                                                                              (callback: GetNotificationCallback): void;
                                                                                                                                                                              };

                                                                                                                                                                                method getMetadata

                                                                                                                                                                                getMetadata: {
                                                                                                                                                                                (
                                                                                                                                                                                options?: GetNotificationMetadataOptions
                                                                                                                                                                                ): Promise<GetNotificationMetadataResponse>;
                                                                                                                                                                                (options: GetNotificationMetadataOptions, callback: MetadataCallback): void;
                                                                                                                                                                                (callback: MetadataCallback): void;
                                                                                                                                                                                };

                                                                                                                                                                                  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 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

                                                                                                                                                                                                    Interfaces

                                                                                                                                                                                                    interface AccessControlObject

                                                                                                                                                                                                    interface AccessControlObject {}

                                                                                                                                                                                                      property entity

                                                                                                                                                                                                      entity: string;

                                                                                                                                                                                                        property projectTeam

                                                                                                                                                                                                        projectTeam: string;

                                                                                                                                                                                                          property role

                                                                                                                                                                                                          role: string;

                                                                                                                                                                                                            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?: Metadata
                                                                                                                                                                                                                    ): 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?: Metadata): void;

                                                                                                                                                                                                                                    interface BucketExistsOptions

                                                                                                                                                                                                                                    interface BucketExistsOptions extends GetConfig {}

                                                                                                                                                                                                                                      property userProject

                                                                                                                                                                                                                                      userProject?: string;

                                                                                                                                                                                                                                        interface BucketLockCallback

                                                                                                                                                                                                                                        interface BucketLockCallback {}

                                                                                                                                                                                                                                          call signature

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

                                                                                                                                                                                                                                            interface BucketOptions

                                                                                                                                                                                                                                            interface BucketOptions {}

                                                                                                                                                                                                                                              property crc32cGenerator

                                                                                                                                                                                                                                              crc32cGenerator?: CRC32CValidatorGenerator;

                                                                                                                                                                                                                                                property kmsKeyName

                                                                                                                                                                                                                                                kmsKeyName?: string;

                                                                                                                                                                                                                                                  property preconditionOpts

                                                                                                                                                                                                                                                  preconditionOpts?: PreconditionOptions;

                                                                                                                                                                                                                                                    property userProject

                                                                                                                                                                                                                                                    userProject?: string;

                                                                                                                                                                                                                                                      interface CombineCallback

                                                                                                                                                                                                                                                      interface CombineCallback {}

                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                        (err: Error | null, newFile: File | null, apiResponse: Metadata): 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?: Metadata): 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?: Metadata;

                                                                                                                                                                                                                                                                                  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 project

                                                                                                                                                                                                                                                                                            project: string;

                                                                                                                                                                                                                                                                                              property userProject

                                                                                                                                                                                                                                                                                              userProject: string;

                                                                                                                                                                                                                                                                                                interface CreateBucketRequest

                                                                                                                                                                                                                                                                                                interface CreateBucketRequest {}

                                                                                                                                                                                                                                                                                                  property archive

                                                                                                                                                                                                                                                                                                  archive?: boolean;

                                                                                                                                                                                                                                                                                                    property coldline

                                                                                                                                                                                                                                                                                                    coldline?: boolean;

                                                                                                                                                                                                                                                                                                      property cors

                                                                                                                                                                                                                                                                                                      cors?: Cors[];

                                                                                                                                                                                                                                                                                                        property customPlacementConfig

                                                                                                                                                                                                                                                                                                        customPlacementConfig?: CustomPlacementConfig;

                                                                                                                                                                                                                                                                                                          property dra

                                                                                                                                                                                                                                                                                                          dra?: boolean;

                                                                                                                                                                                                                                                                                                            property location

                                                                                                                                                                                                                                                                                                            location?: string;

                                                                                                                                                                                                                                                                                                              property multiRegional

                                                                                                                                                                                                                                                                                                              multiRegional?: boolean;

                                                                                                                                                                                                                                                                                                                property nearline

                                                                                                                                                                                                                                                                                                                nearline?: boolean;

                                                                                                                                                                                                                                                                                                                  property regional

                                                                                                                                                                                                                                                                                                                  regional?: boolean;

                                                                                                                                                                                                                                                                                                                    property requesterPays

                                                                                                                                                                                                                                                                                                                    requesterPays?: boolean;

                                                                                                                                                                                                                                                                                                                      property retentionPolicy

                                                                                                                                                                                                                                                                                                                      retentionPolicy?: object;

                                                                                                                                                                                                                                                                                                                        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: Metadata): 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: Metadata
                                                                                                                                                                                                                                                                                                                                                          ): 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 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 {}

                                                                                                                                                                                                                                                                                                                                                                                          property chunkSize

                                                                                                                                                                                                                                                                                                                                                                                          chunkSize?: number;

                                                                                                                                                                                                                                                                                                                                                                                            property metadata

                                                                                                                                                                                                                                                                                                                                                                                            metadata?: Metadata;

                                                                                                                                                                                                                                                                                                                                                                                              property offset

                                                                                                                                                                                                                                                                                                                                                                                              offset?: number;

                                                                                                                                                                                                                                                                                                                                                                                                property origin

                                                                                                                                                                                                                                                                                                                                                                                                origin?: string;

                                                                                                                                                                                                                                                                                                                                                                                                  property preconditionOpts

                                                                                                                                                                                                                                                                                                                                                                                                  preconditionOpts?: PreconditionOptions;

                                                                                                                                                                                                                                                                                                                                                                                                    property predefinedAcl

                                                                                                                                                                                                                                                                                                                                                                                                    predefinedAcl?: PredefinedAcl;

                                                                                                                                                                                                                                                                                                                                                                                                      property private

                                                                                                                                                                                                                                                                                                                                                                                                      private?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                        property public

                                                                                                                                                                                                                                                                                                                                                                                                        public?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                          property uri

                                                                                                                                                                                                                                                                                                                                                                                                          uri?: string;

                                                                                                                                                                                                                                                                                                                                                                                                            property userProject

                                                                                                                                                                                                                                                                                                                                                                                                            userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                              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: Metadata): void;

                                                                                                                                                                                                                                                                                                                                                                                                                              interface DeleteBucketOptions

                                                                                                                                                                                                                                                                                                                                                                                                                              interface DeleteBucketOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                property ignoreNotFound

                                                                                                                                                                                                                                                                                                                                                                                                                                ignoreNotFound?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                  userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DeleteFileCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DeleteFileCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                      (err: Error | null, apiResponse?: Metadata): 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?: Metadata): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface DeleteNotificationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface DeleteNotificationOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                          userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DisableRequesterPaysCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DisableRequesterPaysCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DownloadOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DownloadOptions extends CreateReadStreamOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property destination

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  destination?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EnableRequesterPaysCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EnableRequesterPaysCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (err?: Error | null, apiResponse?: Metadata): 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 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 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 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 virtualHostedStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        virtualHostedStyle?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetAclCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetAclCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            err: Error | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            acl?: AccessControlObject | AccessControlObject[] | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            apiResponse?: Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): 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: Metadata): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetBucketMetadataCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetBucketMetadataCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (err: ApiError | null, metadata: Metadata | null, apiResponse: Metadata): 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?: Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetBucketSignedUrlConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetBucketSignedUrlConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 maxApiCalls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              maxApiCalls?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property maxResults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                maxResults?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property pageToken

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  pageToken?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property prefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    prefix?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property project

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      project?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetExpirationDateCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetExpirationDateCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetFileCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetFileCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetFileMetadataCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetFileMetadataCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetFileMetadataOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetFileMetadataOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetFileOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetFileOptions extends GetConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetFilesCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetFilesCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetFilesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GetFilesOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property autoPaginate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    autoPaginate?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property delimiter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      delimiter?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property endOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        endOffset?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property includeTrailingDelimiter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          includeTrailingDelimiter?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property maxApiCalls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            maxApiCalls?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property maxResults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              maxResults?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property pageToken

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                pageToken?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property prefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  prefix?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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?: Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): 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?: Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): 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?: Metadata): 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: Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): 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?: Metadata): 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?: Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetServiceAccountOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetServiceAccountOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property userProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        userProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetSignedUrlCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface GetSignedUrlCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetSignedUrlConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GetSignedUrlConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property crc32cGenerator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              crc32cGenerator: CRC32CValidatorGenerator;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property md5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                md5: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface HmacKeyMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface HmacKeyMetadata {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property accessId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    accessId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property etag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      etag?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        id?: 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?: Metadata): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface HmacKeyResourceResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface HmacKeyResourceResponse {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          metadata: HmacKeyMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property secret

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            secret: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Labels

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Labels {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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?: Metadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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?: