@super-protocol/sp-cli 0.0.2-beta.9 → 0.0.3

package/dist/commands/files/download.js

@@ -8,13 +8,13 @@ export default class FilesDownload extends BaseCommand {
         // eslint-disable-next-line perfectionist/sort-objects
         localDirectory: Args.string({ description: 'Path to save downloaded file', required: true }),
     };
-    static description = 'describe the command here';
+    static description = 'Download file or directory described in resource file';
     static examples = [
         '<%= config.bin %> <%= command.id %> ./resource.json ./pathToDownload ',
     ];
     static flags = {
         'maximum-concurrent': Flags.integer({
-            default: 1, description: 'Maximum concurrent pieces to upload at once per transfer', max: 1000, min: 1,
+            default: 1, description: 'Maximum concurrent pieces to download at once per transfer', max: 1000, min: 1,
         }),
     };
     static help = 'Download and decrypt a file from the remote storage to <localPath> using resource file <resourcePath>';
@@ -25,20 +25,19 @@ export default class FilesDownload extends BaseCommand {
     async run() {
         const { args, flags } = await this.parse(FilesDownload);
         const { providerClient } = this.container;
-        const storageSerivce = new StorageService(providerClient, this.logger);
+        const storageService = new StorageService(providerClient, this.logger);
         const progress = createProgressPrinter({
             action: 'Download',
             start: 'Downloading: ',
         });
         try {
-            await storageSerivce.download({
+            await storageService.download({
                 downloadPath: args.localDirectory,
                 maximumConcurrent: flags['maximum-concurrent'],
                 resourcePath: args.resourceFile,
             }, ({ current, key, total }) => {
                 progress.advance(key, current / total * 100, `Downloading: ${key} [${current}/${total}]`);
             });
-            progress.finish();
         }
         catch (error) {
             let reason = '';
@@ -48,6 +47,9 @@ export default class FilesDownload extends BaseCommand {
             }
             this.error(`Download aborted. Reason: ${reason}`);
         }
-        this.log('Download successful completed');
+        finally {
+            progress.finish();
+        }
+        this.log('Download successfully completed');
     }
 }

package/dist/commands/files/upload.js

@@ -6,7 +6,7 @@ export default class FilesUpload extends BaseCommand {
     static args = {
         path: Args.string({ description: 'file or directory to upload', required: true }),
     };
-    static description = 'describe the command here';
+    static description = 'Upload file or directory to remote storage';
     static examples = [
         '<%= config.bin %> <%= command.id %> ./file.txt',
     ];
@@ -45,24 +45,23 @@ export default class FilesUpload extends BaseCommand {
     async run() {
         const { args, flags } = await this.parse(FilesUpload);
         const { providerClient } = this.container;
-        const storageSerivce = new StorageService(providerClient, this.logger);
+        const storageService = new StorageService(providerClient, this.logger);
         const progress = createProgressPrinter({
             action: 'Upload',
             start: 'Uploading: ',
         });
         try {
-            await storageSerivce.upload({
+            await storageService.upload({
                 localPath: args.path,
                 maximumConcurrent: flags['maximum-concurrent'],
                 metadataPath: flags.metadata,
                 outputPath: flags.output,
                 remotePath: flags.filename,
                 sync: flags.sync,
-                withEncryption: flags['skip-encryption'],
+                withEncryption: !flags['skip-encryption'],
             }, ({ current, key, total }) => {
                 progress.advance(key, current / total * 100, `Uploading: ${key} [${current}/${total}]`);
             });
-            progress.finish();
         }
         catch (error) {
             let reason = '';
@@ -72,6 +71,9 @@ export default class FilesUpload extends BaseCommand {
             }
             this.error(`Upload aborted. Reason: ${reason}`);
         }
-        this.log('Upload successful completed');
+        finally {
+            progress.finish();
+        }
+        this.log('Upload successfully completed');
     }
 }

package/dist/commands/storage/base.js

@@ -1,6 +1,7 @@
 import { password, select, text } from '@clack/prompts';
 import { StorageType } from '@super-protocol/provider-client';
 import { BaseCommand } from '../../commands/base.js';
+import { S3_REGION } from '../../constants.js';
 import { StorageService } from '../../services/storage.service.js';
 export class BaseStorageCommand extends BaseCommand {
     currentDir = process.cwd();
@@ -12,7 +13,7 @@ export class BaseStorageCommand extends BaseCommand {
         this.storageService = new StorageService(providerClient, this.logger);
     }
     async promptS3Credentials() {
-        const region = 'us-east-1';
+        const region = S3_REGION;
         const readAccessKeyId = this.ensurePromptValue(await text({
             message: 'Read access key ID',
             validate(value) {
@@ -61,6 +62,7 @@ export class BaseStorageCommand extends BaseCommand {
         })).trim();
         const prefix = this.ensurePromptValue(await text({
             defaultValue: '/',
+            initialValue: '/',
             message: 'Prefix',
             validate(value) {
                 return value ? undefined : 'Prefix is required';

package/dist/commands/storage/select.d.ts

@@ -2,8 +2,8 @@ import { BaseStorageCommand } from './base.js';
 export default class StorageSelect extends BaseStorageCommand<typeof StorageSelect> {
     static description: string;
     static examples: string[];
-    static flags: {
-        id: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-    };
-    run(): Promise<void>;
+    run(): Promise<{
+        label: string;
+        selectedStorageId: string;
+    }>;
 }

package/dist/commands/storage/select.js

@@ -1,38 +1,32 @@
 import { select } from '@clack/prompts';
-import { Flags } from '@oclif/core';
 import { StoragesUndefinedError } from '../../services/storage.service.js';
 import { BaseStorageCommand } from './base.js';
 export default class StorageSelect extends BaseStorageCommand {
     static description = 'Select a storage that will be used by subsequent commands.';
     static examples = [
         '<%= config.bin %> storage select',
-        '<%= config.bin %> storage select --id=2de3e3a4-0000-1111-2222-333344445555',
     ];
-    static flags = {
-        id: Flags.string({
-            char: 'i',
-            description: 'Storage ID to select',
-        }),
-    };
     async run() {
-        const { flags } = await this.parse(StorageSelect);
         try {
-            let storageId = flags.id;
-            if (!storageId) {
-                const storages = await this.storageService.requestStorages();
-                storageId = this.ensurePromptValue(await select({
-                    message: 'Select storage',
-                    options: storages.map(storage => ({
-                        label: `${storage.id} (${storage.storageType}) ${storage.bucket}/${storage.prefix} `,
-                        value: storage.id,
-                    })),
-                }));
-            }
+            const storages = await this.storageService.requestStorages();
+            const storageId = this.ensurePromptValue(await select({
+                message: 'Select storage',
+                options: storages.map(storage => ({
+                    label: this.storageService.getLabel(storage),
+                    value: storage.id,
+                })),
+            }));
             if (!storageId) {
                 this.error('Storage ID is required');
             }
+            const storage = storages.find(storage => storage.id === storageId);
+            if (!storage) {
+                this.error(`Storage with ID: ${storageId} not found `);
+            }
+            const label = this.storageService.getLabel(storage);
             await this.storageService.saveStorage(storageId);
-            this.log(`Selected storage: ${storageId}`);
+            this.log(`Selected storage: ${label}`);
+            return { label, selectedStorageId: storageId };
         }
         catch (error) {
             if (error instanceof StoragesUndefinedError) {

package/dist/commands/storage/show.d.ts

@@ -0,0 +1,17 @@
+import { BaseStorageCommand } from './base.js';
+export default class StorageShow extends BaseStorageCommand<typeof StorageShow> {
+    static description: string;
+    static examples: string[];
+    run(): Promise<{
+        bucket: string;
+        createdAt: string;
+        id: string;
+        isCentralized: boolean;
+        prefix: string;
+        s3Credentials?: import("@super-protocol/provider-client").components["schemas"]["S3CredentialsResponseDto"];
+        storageType: import("@super-protocol/provider-client").components["schemas"]["StorageType"];
+        storjCredentials?: import("@super-protocol/provider-client").components["schemas"]["StorJCredentialsResponseDto"];
+        updatedAt: string;
+        userId: string;
+    }>;
+}

package/dist/commands/storage/show.js

@@ -0,0 +1,36 @@
+import { StorageType } from '@super-protocol/provider-client';
+import { BaseStorageCommand } from './base.js';
+const stripString = (str, chars) => {
+    if (str.length <= 2 * chars) {
+        return '*'.repeat(str.length);
+    }
+    return `${str.slice(0, chars)}...${str.slice(-1 * chars)}`;
+};
+export default class StorageShow extends BaseStorageCommand {
+    static description = 'Show current selected storage';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        const storage = await this.storageService.getCurrentStorage();
+        this.log(`Current storage: ${storage.isCentralized ? 'Super Cloud' : 'Custom storage'}`);
+        this.log(`- ID: ${storage.id}`);
+        this.log(`- Storage type: ${storage.storageType}`);
+        this.log(`- Bucket: ${storage.bucket}`);
+        this.log(`- Prefix: ${storage.prefix}`);
+        this.log(' -- Credentials --');
+        if (storage.storageType === StorageType.S3) {
+            const { readAccessKeyId, readSecretAccessKey = '', writeAccessKeyId, writeSecretAccessKey = '' } = storage.s3Credentials || {};
+            this.log(`    readAccessKeyId: ${readAccessKeyId}`);
+            this.log(`    readSecretAccessKey: ${stripString(readSecretAccessKey, 5)}`);
+            this.log(`    writeAccessKeyId: ${writeAccessKeyId}`);
+            this.log(`    writeSecretAccessKey: ${stripString(writeSecretAccessKey, 5)}`);
+        }
+        else {
+            const { readAccessToken = '', writeAccessToken = '' } = storage.storjCredentials || {};
+            this.log(`    readAccessToken: ${stripString(readAccessToken, 5)}`);
+            this.log(`    writeAccessToken: ${stripString(writeAccessToken, 5)}`);
+        }
+        return storage;
+    }
+}

package/dist/commands/workflows/extend-lease.d.ts

@@ -0,0 +1,17 @@
+import { SelectOptions } from '@clack/prompts';
+import { BaseCommand } from '../base.js';
+export default class WorkflowsExtendLease extends BaseCommand<typeof WorkflowsExtendLease> {
+    static args: {
+        orderId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        minutes: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        sppi: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    init(): Promise<void>;
+    run(): Promise<void>;
+    protected selectPrompt<Value>(options: SelectOptions<Value>): Promise<Value>;
+}

package/dist/commands/workflows/extend-lease.js

@@ -0,0 +1,94 @@
+import { select } from '@clack/prompts';
+import { Args, Flags } from '@oclif/core';
+import { Orders } from '@super-protocol/sdk-js';
+import { formatEther, parseEther } from 'viem/utils';
+import { BaseCommand } from '../base.js';
+export default class WorkflowsExtendLease extends BaseCommand {
+    static args = {
+        orderId: Args.string({ description: 'Order ID', required: true }),
+    };
+    static description = 'Replenish deposit for a workflow to extend its lease time';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> <orderId> --sppi 1.5',
+        '<%= config.bin %> <%= command.id %> <orderId> --minutes 120',
+        '<%= config.bin %> <%= command.id %> <orderId> --sppi 2 --yes',
+    ];
+    static flags = {
+        minutes: Flags.integer({ description: 'Time to extend order in minutes (automatically calculates tokens)' }),
+        sppi: Flags.string({ description: 'SPPI token amount to add to the order' }),
+        yes: Flags.boolean({ char: 'y', default: false, description: 'Skip confirmation prompt' }),
+    };
+    async init() {
+        await super.init();
+        await this.container
+            .initConfigManager()
+            .initAccountManager()
+            .initBlockchainConnector()
+            .initProviderClient({ enableAuth: true })
+            .build();
+    }
+    async run() {
+        const { args, flags } = await this.parse(WorkflowsExtendLease);
+        const { providerClient } = this.container;
+        try {
+            this.logger.info(`Checking order ${args.orderId}`);
+            // Get actual per-hour price from blockchain
+            const amountPerHour = await Orders.calculateWorkflowPerHourPrice(args.orderId);
+            let tokenAmount;
+            let minutes;
+            if (flags.minutes) {
+                // Calculate token amount from minutes
+                tokenAmount = (BigInt(amountPerHour) * BigInt(flags.minutes)) / 60n;
+                minutes = flags.minutes;
+            }
+            else if (flags.sppi) {
+                // Use provided SPPI amount
+                tokenAmount = parseEther(flags.sppi);
+                minutes = Number((tokenAmount * 60n) / BigInt(amountPerHour));
+            }
+            else {
+                this.error('Please provide either --sppi or --minutes flag to specify the replenishment amount');
+                return;
+            }
+            // Confirmation prompt
+            const confirmed = this.flags.yes || await this.selectPrompt({
+                message: `Deposit will be replenished by ${formatEther(tokenAmount)} SPPI. Order time is extended by ${minutes} minutes. Confirm?`,
+                options: [
+                    { label: 'Yes', value: true },
+                    { label: 'No', value: false },
+                ],
+            });
+            if (!confirmed) {
+                this.logger.info('Operation cancelled by user');
+                return;
+            }
+            // Call API to replenish deposit
+            const { data, error } = await providerClient.POST('/api/workflows/{orderId}/replenish', {
+                body: {
+                    amount: tokenAmount.toString(),
+                },
+                params: {
+                    path: {
+                        orderId: args.orderId,
+                    },
+                },
+            });
+            if (error) {
+                this.logger.error({ error }, `Order ${args.orderId} was not replenished`);
+                this.error(`Failed to replenish deposit: ${error.message || 'Unknown error'}`);
+                return;
+            }
+            this.logger.info({ data }, 'Deposit replenished successfully');
+            this.log('Deposit replenished successfully');
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            this.logger.error({ error }, `Order ${args.orderId} was not replenished`);
+            this.error(`Order ${args.orderId} was not replenished: ${errorMessage}`);
+        }
+    }
+    async selectPrompt(options) {
+        const result = await select(options);
+        return this.ensurePromptValue(result);
+    }
+}

package/dist/config/config.schema.d.ts

@@ -6,6 +6,10 @@ export declare const accountSchema: Type.TObject<{
 export declare const authSchema: Type.TObject<{
     accessKey: Type.TString;
 }>;
+export declare const blockchainSchema: Type.TObject<{
+    blockchainUrl: Type.TOptional<Type.TString>;
+    contractAddress: Type.TString;
+}>;
 export declare const cliConfigSchema: Type.TObject<{
     account: Type.TOptional<Type.TObject<{
         address: Type.TString;
@@ -14,6 +18,10 @@ export declare const cliConfigSchema: Type.TObject<{
     auth: Type.TOptional<Type.TObject<{
         accessKey: Type.TString;
     }>>;
+    blockchain: Type.TOptional<Type.TObject<{
+        blockchainUrl: Type.TOptional<Type.TString>;
+        contractAddress: Type.TString;
+    }>>;
     cookies: Type.TOptional<Type.TUnknown>;
     name: Type.TOptional<Type.TString>;
     providerUrl: Type.TOptional<Type.TString>;
@@ -22,3 +30,4 @@ export declare const cliConfigSchema: Type.TObject<{
 export type CliConfig = Static<typeof cliConfigSchema>;
 export type Account = Static<typeof accountSchema>;
 export type Auth = Static<typeof authSchema>;
+export type Blockchain = Static<typeof blockchainSchema>;

package/dist/config/config.schema.js

@@ -6,9 +6,14 @@ export const accountSchema = Type.Object({
 export const authSchema = Type.Object({
     accessKey: Type.String(),
 });
+export const blockchainSchema = Type.Object({
+    blockchainUrl: Type.Optional(Type.String({ format: 'url' })),
+    contractAddress: Type.String({ pattern: '^0x[a-fA-F0-9]{40}$' }),
+});
 export const cliConfigSchema = Type.Object({
     account: Type.Optional(accountSchema),
     auth: Type.Optional(authSchema),
+    blockchain: Type.Optional(blockchainSchema),
     cookies: Type.Optional(Type.Unknown()),
     name: Type.Optional(Type.String()),
     providerUrl: Type.Optional(Type.String({ format: 'url' })),

package/dist/constants.d.ts

@@ -3,3 +3,6 @@ export declare const DIR_ACCESS_PERMS = 448;
 export declare const PROVIDER_URL = "https://api.dp.superprotocol.com";
 export declare const REFRESH_TOKEN_URI = "/api/auth/refresh-access";
 export declare const S3_ENDPOINT = "https://gateway.storjshare.io";
+export declare const S3_REGION = "us-east-1";
+export declare const DEFAULT_USER_CONFIG_FILE = "default.config.json";
+export declare const DEFAULT_USER_CONFIG_NAME = "Default";

package/dist/constants.js

@@ -5,3 +5,6 @@ export const DIR_ACCESS_PERMS = 0o700;
 export const PROVIDER_URL = 'https://api.dp.superprotocol.com';
 export const REFRESH_TOKEN_URI = '/api/auth/refresh-access';
 export const S3_ENDPOINT = 'https://gateway.storjshare.io';
+export const S3_REGION = 'us-east-1';
+export const DEFAULT_USER_CONFIG_FILE = 'default.config.json';
+export const DEFAULT_USER_CONFIG_NAME = 'Default';

package/dist/hooks/finally/shutdown-blockchain.d.ts

@@ -0,0 +1,3 @@
+import { Hook } from '@oclif/core';
+declare const hook: Hook<'finally'>;
+export default hook;

package/dist/hooks/finally/shutdown-blockchain.js

@@ -0,0 +1,8 @@
+import { BlockchainConnector } from '@super-protocol/sdk-js';
+const hook = async function () {
+    const connector = BlockchainConnector.getInstance();
+    if (connector.isInitialized()) {
+        connector.shutdown();
+    }
+};
+export default hook;

package/dist/lib/container.d.ts

@@ -25,6 +25,7 @@ export declare class AppContainer {
     get providerClient(): ProviderClient;
     build(): Promise<this>;
     initAccountManager(rebuild?: boolean): this;
+    initBlockchainConnector(): this;
     initConfigFileManager(rebuild?: boolean): this;
     initConfigManager(rebuild?: boolean): this;
     initProviderClient({ enableAuth, enableCookies, rebuild }?: {

package/dist/lib/container.js

@@ -1,4 +1,5 @@
 import { createProviderClient, loggerMiddleware, requestIdMiddleware, } from '@super-protocol/provider-client';
+import { BlockchainConnector } from '@super-protocol/sdk-js';
 import path from 'node:path';
 import { PROVIDER_URL } from '../constants.js';
 import logger from '../logger.js';
@@ -75,6 +76,27 @@ export class AppContainer {
             this._accountManager = accountManager;
         }, rebuild);
     }
+    initBlockchainConnector() {
+        this.initConfigManager();
+        return this.queueInit('blockchainConnector', async () => {
+            await this.waitFor('configManager');
+            let blockchainConfig = await this.configManager.get('blockchain');
+            if (!blockchainConfig) {
+                await this.waitFor('providerClient');
+                const { data, error } = await this.providerClient.GET('/api/config');
+                if (error || !data) {
+                    throw new Error('Could not get configuration from provider');
+                }
+                blockchainConfig = {
+                    blockchainUrl: data.blockchainUrl,
+                    contractAddress: data.contractAddress,
+                };
+                await this.configManager.set('blockchain', blockchainConfig);
+            }
+            this.logger.info('Initializing blockchain connector');
+            await BlockchainConnector.getInstance().initialize(blockchainConfig);
+        });
+    }
     initConfigFileManager(rebuild = false) {
         return this.queueInit('configFileManager', async () => {
             if (this._configFileManager) {
@@ -94,7 +116,7 @@ export class AppContainer {
             if (this._configManager) {
                 return;
             }
-            const configFilePath = this.configFileManager.getCurrentConfigPath();
+            const configFilePath = await this.configFileManager.getCurrentConfigPath();
             if (!configFilePath) {
                 throw new Error('Config file not found');
             }

package/dist/managers/account-manager.d.ts

@@ -13,5 +13,6 @@ export declare class AccountManager implements IAccountManager {
     createSign(nonce: string): Promise<string>;
     getAddress(): string;
     init(): Promise<void>;
+    interactWithUser(): Promise<void>;
     promptAccount(): Promise<Account>;
 }

package/dist/managers/account-manager.js

@@ -65,23 +65,27 @@ export class AccountManager {
         }
         catch (error) {
             this.logger.warn({ err: error }, 'Incorrect config file');
-            ux.warn('Config not found or have errors');
-            const ask = await confirm({
-                message: 'Do you want to create new one?',
-            });
-            if (isCancel(ask)) {
-                ux.error('Operation cancelled.', { exit: 1 });
-            }
-            if (ask) {
-                await this.promptAccount();
-            }
-            else {
-                ux.error('Credentials not generated please check config file and rerun command again', { exit: 1 });
-            }
+            await this.interactWithUser();
+        }
+    }
+    async interactWithUser() {
+        ux.warn("Account doesn't exist in current configuration");
+        const ask = await confirm({
+            message: 'Do you want to create a new account?',
+        });
+        if (isCancel(ask)) {
+            ux.error('Operation cancelled.', { exit: 1 });
+        }
+        if (ask) {
+            await this.promptAccount();
+        }
+        else {
+            ux.error('Credentials not generated please check config file and rerun command again', { exit: 1 });
         }
     }
     async promptAccount() {
         const askPrivateKey = await confirm({
+            initialValue: false,
             message: 'Do you want to input privateKey?',
         });
         if (isCancel(askPrivateKey)) {

package/dist/managers/config-file-manager.d.ts

@@ -37,7 +37,7 @@ export declare class ConfigFileManager implements IManager {
         name: string;
     }>;
     getCurrentConfigFile(): string | undefined;
-    getCurrentConfigPath(): string | undefined;
+    getCurrentConfigPath(): Promise<string>;
     importConfig(sourcePath: string, targetName?: string): Promise<string>;
     init(): Promise<void>;
     removeConfig(configName: string): Promise<void>;

package/dist/managers/config-file-manager.js

@@ -4,7 +4,7 @@ import * as fs from 'node:fs';
 import path from 'node:path';
 import { Value } from 'typebox/value';
 import { cliConfigSchema } from '../config/config.schema.js';
-import { DIR_ACCESS_PERMS, FILE_ACCESS_PERMS } from '../constants.js';
+import { DEFAULT_USER_CONFIG_FILE, DEFAULT_USER_CONFIG_NAME, DIR_ACCESS_PERMS, FILE_ACCESS_PERMS, } from '../constants.js';
 import { getConfigName } from '../utils/helper.js';
 export class ConfigFileManager {
     logger;
@@ -165,14 +165,26 @@ export class ConfigFileManager {
         }
         return this.configs.currentConfig;
     }
-    getCurrentConfigPath() {
+    async getCurrentConfigPath() {
         if (this.runtimeConfigFile) {
             return this.runtimeConfigFile;
         }
         if (!this.configs.currentConfig) {
-            return undefined;
+            try {
+                await this.createConfig(DEFAULT_USER_CONFIG_FILE, DEFAULT_USER_CONFIG_NAME);
+            }
+            catch {
+                //
+            }
+            try {
+                await this.setCurrentConfig(DEFAULT_USER_CONFIG_FILE);
+            }
+            catch (error) {
+                this.logger.error({ err: error }, 'Failed to set default config');
+                throw error;
+            }
         }
-        return path.join(this.configsDir, this.configs.currentConfig);
+        return path.join(this.configsDir, this.configs.currentConfig || DEFAULT_USER_CONFIG_FILE);
     }
     async importConfig(sourcePath, targetName) {
         if (!fs.existsSync(sourcePath)) {

package/dist/services/storage.service.d.ts

@@ -43,6 +43,7 @@ export declare class StorageService {
     download(params: IDownloadParams, progressCb: ProgressCb): Promise<void>;
     getCentralizedStorage(): Promise<StorageResponseDto>;
     getCurrentStorage(): Promise<StorageResponseDto>;
+    getLabel(storage: StorageResponseDto): string;
     hasStorage(): Promise<boolean>;
     initCentralizedStorage(): Promise<{
         bucket: string;
@@ -64,8 +65,9 @@ export declare class StorageService {
         id: string;
         updatedAt: string;
         userId: string;
-    }>;
+    } | undefined>;
     updateStorage(id: string, storage: UpdateStorageDto): Promise<StorageResponseDto>;
     upload(params: IUploadParams, progressCb: ProgressCb): Promise<void>;
+    private getStorageCredentials;
 }
 export {};