@firebase/storage-types

app: FirebaseApp;

maxOperationRetryTime: number;

maxUploadRetryTime: number;

ref: (path?: string) => Reference;

refFromURL: (url: string) => Reference;

setMaxOperationRetryTime: (time: number) => void;

setMaxUploadRetryTime: (time: number) => void;

useEmulator: (
    host: string,
    port: number,
    options?: { mockUserToken?: EmulatorMockTokenOptions | string }
) => void;

customData: {
    serverResponse: string | null;
};

get status(): number;

set status(status: number);

get serverResponse(): null | string;

set serverResponse(serverResponse: string | null);

bucket: string;

fullPath: string;

generation: string;

metageneration: string;

name: string;

size: number;

timeCreated: string;

updated: string;

maxResults?: number | null;

pageToken?: string | null;

items: Reference[];

nextPageToken: string | null;

prefixes: Reference[];

bucket: string;

fullPath: string;

name: string;

parent: Reference | null;

root: Reference;

storage: FirebaseStorage;

child: (path: string) => Reference;

delete: () => Promise<void>;

getDownloadURL: () => Promise<string>;

getMetadata: () => Promise<FullMetadata>;

list: (options?: ListOptions) => Promise<ListResult>;

listAll: () => Promise<ListResult>;

put: (
    data: Blob | Uint8Array | ArrayBuffer,
    metadata?: UploadMetadata
) => UploadTask;

putString: (
    data: string,
    format?: StringFormat,
    metadata?: UploadMetadata
) => UploadTask;

toString: () => string;

updateMetadata: (metadata: SettableMetadata) => Promise<FullMetadata>;

cacheControl?: string | null;

contentDisposition?: string | null;

contentEncoding?: string | null;

contentLanguage?: string | null;

contentType?: string | null;

customMetadata?: {
    [/* warning: coerced from ? */ key: string]: string;
} | null;

complete?: CompleteFn | null;

error?: (error: FirebaseStorageError) => void | null;

next?: NextFn<T> | null;

md5Hash?: string | null;

snapshot: UploadTaskSnapshot;

cancel: () => boolean;

catch: (onRejected: (error: FirebaseStorageError) => any) => Promise<any>;

on: (
    event: TaskEvent,
    nextOrObserver?:
        | StorageObserver<UploadTaskSnapshot>
        | ((snapshot: UploadTaskSnapshot) => any),
    error?: (a: FirebaseStorageError) => any,
    complete?: Unsubscribe | null
) => Function;

pause: () => boolean;

resume: () => boolean;

then: (
    onFulfilled?: (snapshot: UploadTaskSnapshot) => any,
    onRejected?: (error: FirebaseStorageError) => any
) => Promise<any>;

bytesTransferred: number;

metadata: FullMetadata;

ref: Reference;

state: TaskState;

task: UploadTask;

totalBytes: number;

APP_DELETED = 'app-deleted'

BUCKET_NOT_FOUND = 'bucket-not-found'

CANCELED = 'canceled'

CANNOT_SLICE_BLOB = 'cannot-slice-blob'

INTERNAL_ERROR = 'internal-error'

INVALID_ARGUMENT = 'invalid-argument'

INVALID_ARGUMENT_COUNT = 'invalid-argument-count'

INVALID_CHECKSUM = 'invalid-checksum'

INVALID_DEFAULT_BUCKET = 'invalid-default-bucket'

INVALID_EVENT_NAME = 'invalid-event-name'

INVALID_FORMAT = 'invalid-format'

INVALID_ROOT_OPERATION = 'invalid-root-operation'

INVALID_URL = 'invalid-url'

NO_DEFAULT_BUCKET = 'no-default-bucket'

NO_DOWNLOAD_URL = 'no-download-url'

OBJECT_NOT_FOUND = 'object-not-found'

PROJECT_NOT_FOUND = 'project-not-found'

QUOTA_EXCEEDED = 'quota-exceeded'

RETRY_LIMIT_EXCEEDED = 'retry-limit-exceeded'

SERVER_FILE_WRONG_SIZE = 'server-file-wrong-size'

UNAUTHENTICATED = 'unauthenticated'

UNAUTHORIZED = 'unauthorized'

UNAUTHORIZED_APP = 'unauthorized-app'

UNKNOWN = 'unknown'

UNSUPPORTED_ENVIRONMENT = 'unsupported-environment'