@google-cloud/storage

constructor

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

property acl

acl: Acl;

property getFilesStream

getFilesStream: Function;

property iam

iam: Iam;

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,
        options?: AddLifecycleRuleOptions
    ): Promise<SetBucketMetadataResponse>;
    (
        rule: LifecycleRule,
        options: AddLifecycleRuleOptions,
        callback: SetBucketMetadataCallback
    ): void;
    (rule: 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>;
    (callback: SetLabelsCallback): void;
    (labels: string | string[], callback: SetLabelsCallback): void;
};

method disableRequesterPays

disableRequesterPays: {
    (): Promise<DisableRequesterPaysResponse>;
    (callback: DisableRequesterPaysCallback): void;
};

method enableLogging

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

method enableRequesterPays

enableRequesterPays: {
    (): Promise<EnableRequesterPaysResponse>;
    (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](https://cloud.google.com/storage/docs/encryption#customer-supplied).

  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 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: {
    (): Promise<SetBucketMetadataResponse>;
    (callback: SetBucketMetadataCallback): void;
};

method request

request: {
    (reqOpts: any): Promise<[ResponseBody, Metadata]>;
    (reqOpts: any, callback: any): void;
};

method setCorsConfiguration

setCorsConfiguration: {
    (corsConfiguration: Cors[]): Promise<SetBucketMetadataResponse>;
    (corsConfiguration: Cors[], 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 setRetentionPeriod

setRetentionPeriod: {
    (duration: number): Promise<SetBucketMetadataResponse>;
    (duration: number, 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;
};

constructor

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

method stop

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

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 generation

generation?: number;

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) => any;

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

  For faster crc32c computation, you must manually install [fast-crc32c](https://www.npmjs.com/package/fast-crc32c):

  $ npm install --save fast-crc32c

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

  Parameter options

  Configuration options.

  Returns

  {ReadableStream}

  Example 1

  //- // Downloading a File // // 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) => any;

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

  Resumable uploads require write access to the $HOME directory. Through [config-store](https://www.npmjs.com/package/configstore), some metadata is stored. By default, if the directory is not writable, we will fall back to a simple upload. However, if you explicitly request a resumable upload, and we cannot write to the config directory, we will return a ResumableUploadError.

  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.

  For faster crc32c computation, you must manually install [fast-crc32c](https://www.npmjs.com/package/fast-crc32c):

  $ npm install --save fast-crc32c

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

  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');

  //- // Uploading a File // // Now, consider a case where we want to upload a file to your bucket. You // have the option of using 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. });

  //- // Uploading a File with gzip compression //- 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. //-

  //- // Uploading a File with Metadata // // 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 // 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. });

  See Also

  • [Upload Options (Simple or Resumable)]https://cloud.google.com/storage/docs/json_api/v1/how-tos/upload

  • [Objects: insert API Documentation]https://cloud.google.com/storage/docs/json_api/v1/objects/insert

method deleteResumableCache

deleteResumableCache: () => void;

• Delete failed resumable upload file cache.

  Resumable file upload cache the config file to restart upload in case of failure. In certain scenarios, the resumable upload will not works and upload file cache needs to be deleted to upload the same file.

  Following are some of the scenarios.

  Resumable file upload failed even though the file is successfully saved on the google storage and need to clean up a resumable file cache to update the same file.

  Resumable file upload failed due to pre-condition (i.e generation number is not matched) and want to upload a same file with the new generation number.

  Example 1

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

  const file = myBucket.file('my-file', { generation: 0 }); const contents = 'This is the contents of the file.';

  file.save(contents, function(err) { if (err) { file.deleteResumableCache(); } });

method download

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

method generateSignedPostPolicyV2

generateSignedPostPolicyV2: {
    (
        options: GenerateSignedPostPolicyV2Options
    ): Promise<GenerateSignedPostPolicyV2Response>;
    (options: GetSignedPolicyOptions, callback: GetSignedPolicyCallback): void;
    (callback: GetSignedPolicyCallback): 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 getSignedPolicy

getSignedPolicy: {
    (options: GetSignedPolicyOptions): Promise<GetSignedPolicyResponse>;
    (options: GetSignedPolicyOptions, callback: GetSignedPolicyCallback): void;
    (callback: GetSignedPolicyCallback): 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: any): Promise<[ResponseBody, Metadata]>;
    (reqOpts: any, callback: any): 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.

  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:

  See Also

  • [Customer-supplied Encryption Keys]https://cloud.google.com/storage/docs/encryption#customer-supplied

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: any, options: CreateResumableUploadOptions) => void;

• This creates a gcs-resumable-upload upload stream.

  Parameter stream

  Duplexify stream of data to pipe to the file.

  Parameter options

  Configuration object.

  See Also

  • [gcs-resumable-upload]https://github.com/stephenplusplus/gcs-resumable-upload

method startSimpleUpload_

startSimpleUpload_: (dup: any, 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.

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;

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

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: any): void;
    (callback: any): void;
};

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

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 File

static File: typeof File;

• File class.

  Storage.File

  See Also

  • File {Constructor}

property getBucketsStream

getBucketsStream: () => any;

property getHmacKeysStream

getHmacKeysStream: () => any;

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

  Returns

  {HmacKey}

  Example 1

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

  See Also

  • HmacKey

property entity

entity: string;

property projectTeam

projectTeam: string;

property role

role: string;

property pathPrefix

pathPrefix: string;

property request

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

call signature

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

property entity

entity: string;

property generation