@super-protocol/sp-cli 0.0.6 → 0.0.8

package/dist/commands/base.js

@@ -1,14 +1,36 @@
-import { isCancel } from '@clack/prompts';
-import { Command, Flags, } from '@oclif/core';
+import { Command, Flags } from '@oclif/core';
 import { AppContainer } from '../lib/container.js';
 import logger from '../logger.js';
+import { findMissingRequiredArgs, findMissingRequiredFlags, formatMissingArgsError, formatMissingFlagsError, promptForArg, promptForFlag, } from '../utils/prompt-flags.js';
+import { promptService } from '../utils/prompt.service.js';
+import { isInteractiveMode } from '../utils/tty.js';
+const relaxRequired = (definitions) => {
+    if (!definitions) {
+        return definitions;
+    }
+    return Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [
+        name,
+        {
+            ...definition,
+            required: false,
+        },
+    ]));
+};
 export class BaseCommand extends Command {
+    static authenticate = true;
     static baseFlags = {
         config: Flags.string({
             helpGroup: 'GLOBAL',
+            hidden: true,
             required: false,
             summary: 'Specify config file.',
         }),
+        tty: Flags.boolean({
+            allowNo: true,
+            helpGroup: 'GLOBAL',
+            required: false,
+            summary: 'Force or disable interactive mode (use --no-tty to disable).',
+        }),
     };
     static enableJsonFlag = true;
     args;
@@ -20,24 +42,88 @@ export class BaseCommand extends Command {
         this.logger = logger.getPino();
     }
     ensurePromptValue(value, errorMessage = 'Operation cancelled.') {
-        if (isCancel(value)) {
-            this.error(errorMessage);
+        try {
+            return promptService.ensureValue(value, errorMessage);
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
         }
-        return value;
     }
     async init() {
         await super.init();
-        const { args, flags } = await this.parse({
-            args: this.ctor.args,
-            baseFlags: super.ctor.baseFlags,
+        const allFlags = { ...this.ctor.flags, ...super.ctor.baseFlags };
+        const relaxedArgs = relaxRequired(this.ctor.args);
+        const relaxedFlags = relaxRequired(this.ctor.flags);
+        const relaxedBaseFlags = relaxRequired(super.ctor.baseFlags);
+        let parsedResult = await this.parse({
+            args: relaxedArgs,
+            baseFlags: relaxedBaseFlags,
             enableJsonFlag: this.ctor.enableJsonFlag,
-            flags: this.ctor.flags,
-            strict: this.ctor.strict,
+            flags: relaxedFlags,
+            strict: false,
         });
-        this.flags = flags;
-        this.args = args;
+        const isInteractive = isInteractiveMode(parsedResult.flags.tty);
+        const missingFlags = await findMissingRequiredFlags(parsedResult.flags, allFlags);
+        const missingArgs = await findMissingRequiredArgs(parsedResult.args, this.ctor.args);
+        if (missingFlags.length > 0 || missingArgs.length > 0) {
+            if (!isInteractive) {
+                const errors = [];
+                if (missingFlags.length > 0) {
+                    errors.push(formatMissingFlagsError(missingFlags));
+                }
+                if (missingArgs.length > 0) {
+                    errors.push(formatMissingArgsError(missingArgs));
+                }
+                this.error(errors.join(' '), { exit: 1 });
+            }
+            const argValues = [];
+            for (const missingArg of missingArgs) {
+                const value = await promptForArg(missingArg);
+                argValues.push(String(value));
+            }
+            const flagPairs = [];
+            for (const missingFlag of missingFlags) {
+                const value = await promptForFlag(missingFlag);
+                if (missingFlag.type === 'boolean') {
+                    const boolValue = Boolean(value);
+                    if (boolValue) {
+                        flagPairs.push(`--${missingFlag.name}`);
+                    }
+                    else if ('allowNo' in missingFlag.definition &&
+                        Boolean(missingFlag.definition.allowNo)) {
+                        flagPairs.push(`--no-${missingFlag.name}`);
+                    }
+                    else {
+                        this.error(`Flag --${missingFlag.name} is required and only supports "true".`);
+                    }
+                }
+                else {
+                    flagPairs.push(`--${missingFlag.name}`, String(value));
+                }
+            }
+            const updatedArgv = [...this.argv, ...argValues, ...flagPairs];
+            this.argv = updatedArgv;
+            parsedResult = await this.parse({
+                args: this.ctor.args,
+                baseFlags: super.ctor.baseFlags,
+                enableJsonFlag: this.ctor.enableJsonFlag,
+                flags: this.ctor.flags,
+                strict: this.ctor.strict,
+            });
+        }
+        else if (this.ctor.strict) {
+            parsedResult = await this.parse({
+                args: this.ctor.args,
+                baseFlags: super.ctor.baseFlags,
+                enableJsonFlag: this.ctor.enableJsonFlag,
+                flags: this.ctor.flags,
+                strict: true,
+            });
+        }
+        this.flags = parsedResult.flags;
+        this.args = parsedResult.args;
         this.container = AppContainer.container.setupRuntimeConfig({
-            configFile: flags.config,
+            configFile: parsedResult.flags.config,
         });
     }
 }

package/dist/commands/files/download.js

@@ -4,9 +4,14 @@ import { createProgressPrinter } from '../../utils/progress.js';
 import { BaseCommand } from '../base.js';
 export default class FilesDownload extends BaseCommand {
     static args = {
-        resourceFile: Args.string({ description: 'Path to a resource file', required: true }),
-        // eslint-disable-next-line perfectionist/sort-objects
-        localDirectory: Args.string({ description: 'Path to save downloaded file', required: true }),
+        resourceFile: Args.string({
+            description: 'Path to a resource file',
+            required: true,
+        }),
+        localDirectory: Args.string({
+            description: 'Path to save downloaded file',
+            required: true,
+        }),
     };
     static description = 'Download file or directory described in resource file';
     static examples = [
@@ -14,7 +19,10 @@ export default class FilesDownload extends BaseCommand {
     ];
     static flags = {
         'maximum-concurrent': Flags.integer({
-            default: 1, description: 'Maximum concurrent pieces to download 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>';
@@ -36,7 +44,7 @@ export default class FilesDownload extends BaseCommand {
                 maximumConcurrent: flags['maximum-concurrent'],
                 resourcePath: args.resourceFile,
             }, ({ current, key, total }) => {
-                progress.advance(key, current / total * 100, `Downloading: ${key} [${current}/${total}]`);
+                progress.advance(key, (current / total) * 100, `Downloading: ${key} [${current}/${total}]`);
             });
         }
         catch (error) {

package/dist/commands/files/upload.js

@@ -4,19 +4,23 @@ import { createProgressPrinter } from '../../utils/progress.js';
 import { BaseCommand } from '../base.js';
 export default class FilesUpload extends BaseCommand {
     static args = {
-        path: Args.string({ description: 'file or directory to upload', required: true }),
+        path: Args.string({
+            description: 'file or directory to upload',
+            required: true,
+        }),
     };
     static description = 'Upload file or directory to remote storage';
-    static examples = [
-        '<%= config.bin %> <%= command.id %> ./file.txt',
-    ];
+    static examples = ['<%= config.bin %> <%= command.id %> ./file.txt'];
     static flags = {
         filename: Flags.string({
             description: 'The name of the resulting file/directory in the storage',
             required: false,
         }),
         '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 upload at once per transfer',
+            max: 1000,
+            min: 1,
         }),
         metadata: Flags.string({
             description: 'Path to a metadata file for adding fields to the resource file',
@@ -34,7 +38,7 @@ export default class FilesUpload extends BaseCommand {
         }),
         sync: Flags.boolean({
             default: false,
-            description: 'Sync mode: delete files in target that don\'t exist in source',
+            description: "Sync mode: delete files in target that don't exist in source",
             required: false,
         }),
     };
@@ -60,7 +64,7 @@ export default class FilesUpload extends BaseCommand {
                 sync: flags.sync,
                 withEncryption: !flags['skip-encryption'],
             }, ({ current, key, total }) => {
-                progress.advance(key, current / total * 100, `Uploading: ${key} [${current}/${total}]`);
+                progress.advance(key, (current / total) * 100, `Uploading: ${key} [${current}/${total}]`);
             });
         }
         catch (error) {

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

@@ -1,5 +1,5 @@
-import { Command } from '@oclif/core';
-import { AddStorageDto } from '@super-protocol/provider-client';
+import type { Command } from '@oclif/core';
+import { type AddStorageDto } from '@super-protocol/provider-client';
 import { BaseCommand } from '../../commands/base.js';
 import { StorageService } from '../../services/storage.service.js';
 export declare abstract class BaseStorageCommand<T extends typeof Command> extends BaseCommand<T> {

package/dist/commands/storage/base.js

@@ -1,8 +1,8 @@
-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';
+import { promptService } from '../../utils/prompt.service.js';
 export class BaseStorageCommand extends BaseCommand {
     currentDir = process.cwd();
     storageService;
@@ -14,25 +14,25 @@ export class BaseStorageCommand extends BaseCommand {
     }
     async promptS3Credentials() {
         const region = S3_REGION;
-        const readAccessKeyId = this.ensurePromptValue(await text({
+        const readAccessKeyId = (await promptService.text({
             message: 'Read access key ID',
             validate(value) {
                 return value ? undefined : 'Read access key ID is required';
             },
         })).trim();
-        const readSecretAccessKey = this.ensurePromptValue(await password({
+        const readSecretAccessKey = (await promptService.password({
             message: 'Read secret access key',
             validate(value) {
                 return value ? undefined : 'Read secret access key is required';
             },
         })).trim();
-        const writeAccessKeyId = this.ensurePromptValue(await text({
+        const writeAccessKeyId = (await promptService.text({
             message: 'Write access key ID',
             validate(value) {
                 return value ? undefined : 'Write access key ID is required';
             },
         })).trim();
-        const writeSecretAccessKey = this.ensurePromptValue(await password({
+        const writeSecretAccessKey = (await promptService.password({
             message: 'Write secret access key',
             validate(value) {
                 return value ? undefined : 'Write secret access key is required';
@@ -47,20 +47,20 @@ export class BaseStorageCommand extends BaseCommand {
         };
     }
     async promptStoragePayload() {
-        const storageType = this.ensurePromptValue(await select({
+        const storageType = await promptService.select({
             message: 'Select storage type',
             options: [
                 { label: 'S3', value: StorageType.S3 },
                 { label: 'StorJ', value: StorageType.StorJ },
             ],
-        }));
-        const bucket = this.ensurePromptValue(await text({
+        });
+        const bucket = (await promptService.text({
             message: 'Bucket name',
             validate(value) {
                 return value ? undefined : 'Bucket is required';
             },
         })).trim();
-        const prefix = this.ensurePromptValue(await text({
+        const prefix = (await promptService.text({
             defaultValue: '/',
             initialValue: '/',
             message: 'Prefix',
@@ -82,13 +82,13 @@ export class BaseStorageCommand extends BaseCommand {
         return storage;
     }
     async promptStorJCredentials() {
-        const readAccessToken = this.ensurePromptValue(await password({
+        const readAccessToken = (await promptService.password({
             message: 'Read access token',
             validate(value) {
                 return value ? undefined : 'Read access token is required';
             },
         })).trim();
-        const writeAccessToken = this.ensurePromptValue(await password({
+        const writeAccessToken = (await promptService.password({
             message: 'Write access token',
             validate(value) {
                 return value ? undefined : 'Write access token is required';

package/dist/commands/storage/create.js

@@ -1,6 +1,6 @@
-import { Flags } from '@oclif/core';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { Flags } from '@oclif/core';
 import { BaseStorageCommand } from './base.js';
 export default class StorageCreate extends BaseStorageCommand {
     static description = 'Create a new storage entry from file or interactive prompts.';

package/dist/commands/storage/select.js

@@ -1,25 +1,23 @@
-import { select } from '@clack/prompts';
 import { StoragesUndefinedError } from '../../services/storage.service.js';
+import { promptService } from '../../utils/prompt.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',
-    ];
+    static examples = ['<%= config.bin %> storage select'];
     async run() {
         try {
             const storages = await this.storageService.requestStorages();
-            const storageId = this.ensurePromptValue(await select({
+            const storageId = await promptService.select({
                 message: 'Select storage',
-                options: storages.map(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);
+            const storage = storages.find((storage) => storage.id === storageId);
             if (!storage) {
                 this.error(`Storage with ID: ${storageId} not found `);
             }

package/dist/commands/storage/show.js

@@ -8,9 +8,7 @@ const stripString = (str, chars) => {
 };
 export default class StorageShow extends BaseStorageCommand {
     static description = 'Show current selected storage';
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-    ];
+    static examples = ['<%= config.bin %> <%= command.id %>'];
     async run() {
         const storage = await this.storageService.getCurrentStorage();
         this.log(`Current storage: ${storage.isCentralized ? 'Super Cloud' : 'Custom storage'}`);
@@ -20,7 +18,7 @@ export default class StorageShow extends BaseStorageCommand {
         this.log(`- Prefix: ${storage.prefix}`);
         this.log(' -- Credentials --');
         if (storage.storageType === StorageType.S3) {
-            const { readAccessKeyId, readSecretAccessKey = '', writeAccessKeyId, writeSecretAccessKey = '' } = storage.s3Credentials || {};
+            const { readAccessKeyId, readSecretAccessKey = '', writeAccessKeyId, writeSecretAccessKey = '', } = storage.s3Credentials || {};
             this.log(`    readAccessKeyId: ${readAccessKeyId}`);
             this.log(`    readSecretAccessKey: ${stripString(readSecretAccessKey, 5)}`);
             this.log(`    writeAccessKeyId: ${writeAccessKeyId}`);

package/dist/commands/storage/update.js

@@ -1,9 +1,9 @@
-import { confirm, select, text, } from '@clack/prompts';
-import { Flags } from '@oclif/core';
-import { StorageType } from '@super-protocol/provider-client';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { Flags } from '@oclif/core';
+import { StorageType, } from '@super-protocol/provider-client';
 import { StoragesUndefinedError } from '../../services/storage.service.js';
+import { promptService } from '../../utils/prompt.service.js';
 import { BaseStorageCommand } from './base.js';
 export default class StorageUpdate extends BaseStorageCommand {
     static description = 'Update the configuration of an existing storage.';
@@ -25,25 +25,29 @@ export default class StorageUpdate extends BaseStorageCommand {
         const { flags } = await this.parse(StorageUpdate);
         try {
             const shouldRequestStorages = !flags.fromFile || !flags.id;
-            const storages = shouldRequestStorages ? await this.storageService.requestStorages() : undefined;
+            const storages = shouldRequestStorages
+                ? await this.storageService.requestStorages()
+                : undefined;
             let storageId = flags.id;
             if (!storageId) {
-                const options = (storages || []).filter(cp => !cp.isCentralized).map(storage => ({
+                const options = (storages || [])
+                    .filter((cp) => !cp.isCentralized)
+                    .map((storage) => ({
                     label: `${storage.id} (${storage.storageType}) ${storage.bucket}/${storage.prefix} `,
                     value: storage.id,
                 }));
                 if (!options || options.length === 0) {
                     throw new StoragesUndefinedError('No storages available to update');
                 }
-                storageId = this.ensurePromptValue(await select({
+                storageId = await promptService.select({
                     message: 'Select storage to update',
                     options,
-                }));
+                });
             }
             if (!storageId) {
                 this.error('Storage ID is required');
             }
-            const storageToUpdate = storages?.find(storage => storage.id === storageId);
+            const storageToUpdate = storages?.find((storage) => storage.id === storageId);
             if (flags.id && storages && !storageToUpdate) {
                 this.error(`Storage with ID ${storageId} not found`);
             }
@@ -72,8 +76,14 @@ export default class StorageUpdate extends BaseStorageCommand {
         if (!payload || typeof payload !== 'object') {
             this.error('Storage update definition must be an object');
         }
-        const updateFields = ['bucket', 'prefix', 'storageType', 's3Credentials', 'storjCredentials'];
-        const hasUpdates = updateFields.some(key => payload[key] !== undefined);
+        const updateFields = [
+            'bucket',
+            'prefix',
+            'storageType',
+            's3Credentials',
+            'storjCredentials',
+        ];
+        const hasUpdates = updateFields.some((key) => payload[key] !== undefined);
         if (!hasUpdates) {
             this.error('Update payload must include at least one property');
         }
@@ -82,7 +92,11 @@ export default class StorageUpdate extends BaseStorageCommand {
         }
         if (payload.s3Credentials) {
             const { readAccessKeyId, readSecretAccessKey, region, writeAccessKeyId, writeSecretAccessKey, } = payload.s3Credentials;
-            if (!readAccessKeyId || !readSecretAccessKey || !region || !writeAccessKeyId || !writeSecretAccessKey) {
+            if (!readAccessKeyId ||
+                !readSecretAccessKey ||
+                !region ||
+                !writeAccessKeyId ||
+                !writeSecretAccessKey) {
                 this.error('S3 credentials must include readAccessKeyId, readSecretAccessKey, region, writeAccessKeyId and writeSecretAccessKey');
             }
         }
@@ -120,7 +134,9 @@ export default class StorageUpdate extends BaseStorageCommand {
         return sanitized;
     }
     async loadStorageFromFile(filePath) {
-        const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(this.currentDir, filePath);
+        const absolutePath = path.isAbsolute(filePath)
+            ? filePath
+            : path.join(this.currentDir, filePath);
         try {
             const fileContent = await fs.readFile(absolutePath, 'utf8');
             const parsed = JSON.parse(fileContent);
@@ -132,14 +148,14 @@ export default class StorageUpdate extends BaseStorageCommand {
     }
     async promptStorageUpdate(existingStorage) {
         const payload = {};
-        const bucket = this.ensurePromptValue(await text({
+        const bucket = (await promptService.text({
             defaultValue: existingStorage?.bucket ?? '',
             message: 'Bucket name (leave empty to keep current)',
         })).trim();
         if (bucket) {
             payload.bucket = bucket;
         }
-        const prefix = this.ensurePromptValue(await text({
+        const prefix = (await promptService.text({
             defaultValue: existingStorage?.prefix ?? '',
             message: 'Prefix (leave empty to keep current)',
         })).trim();
@@ -147,29 +163,30 @@ export default class StorageUpdate extends BaseStorageCommand {
             payload.prefix = prefix;
         }
         let newStorageType;
-        const shouldChangeType = this.ensurePromptValue(await confirm({
+        const shouldChangeType = await promptService.confirm({
             initialValue: false,
             message: existingStorage
                 ? `Change storage type? (current: ${existingStorage.storageType})`
                 : 'Change storage type?',
-        }));
+        });
         if (shouldChangeType) {
-            newStorageType = this.ensurePromptValue(await select({
+            newStorageType = await promptService.select({
                 message: 'Select new storage type',
                 options: [
                     { label: 'Amazon S3', value: StorageType.S3 },
                     { label: 'StorJ', value: StorageType.StorJ },
                 ],
-            }));
+            });
             payload.storageType = newStorageType;
         }
         const effectiveType = newStorageType ?? existingStorage?.storageType;
         const credentialsRequired = Boolean(newStorageType);
         if (effectiveType) {
-            const updateCredentials = credentialsRequired || this.ensurePromptValue(await confirm({
-                initialValue: false,
-                message: `Update ${effectiveType} credentials?`,
-            }));
+            const updateCredentials = credentialsRequired ||
+                (await promptService.confirm({
+                    initialValue: false,
+                    message: `Update ${effectiveType} credentials?`,
+                }));
             if (updateCredentials) {
                 if (effectiveType === StorageType.S3) {
                     payload.s3Credentials = await this.promptS3Credentials();

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

@@ -1,4 +1,4 @@
-import { SelectOptions } from '@clack/prompts';
+import { type SelectOptions } from '../../utils/prompt.service.js';
 import { BaseCommand } from '../base.js';
 export default class WorkflowsExtendLease extends BaseCommand<typeof WorkflowsExtendLease> {
     static args: {

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

@@ -1,7 +1,7 @@
-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 { promptService } from '../../utils/prompt.service.js';
 import { BaseCommand } from '../base.js';
 export default class WorkflowsExtendLease extends BaseCommand {
     static args = {
@@ -14,9 +14,17 @@ export default class WorkflowsExtendLease extends BaseCommand {
         '<%= 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' }),
+        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();
@@ -51,13 +59,14 @@ export default class WorkflowsExtendLease extends BaseCommand {
                 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 },
-                ],
-            });
+            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;
@@ -88,7 +97,6 @@ export default class WorkflowsExtendLease extends BaseCommand {
         }
     }
     async selectPrompt(options) {
-        const result = await select(options);
-        return this.ensurePromptValue(result);
+        return promptService.select(options);
     }
 }

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

@@ -1,6 +1,5 @@
-import { Static, Type } from 'typebox';
+import { type Static, Type } from 'typebox';
 export declare const configFileManagerSchema: Type.TObject<{
-    configs: Type.TArray<Type.TString>;
     currentConfig: Type.TOptional<Type.TString>;
 }>;
 export type ConfigFileManagerData = Static<typeof configFileManagerSchema>;

package/dist/config/config-file.schema.js

@@ -1,5 +1,4 @@
 import { Type } from 'typebox';
 export const configFileManagerSchema = Type.Object({
-    configs: Type.Array(Type.String()),
     currentConfig: Type.Optional(Type.String()),
 });

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

@@ -1,4 +1,4 @@
-import { Static, Type } from 'typebox';
+import { type Static, Type } from 'typebox';
 export declare const accountSchema: Type.TObject<{
     address: Type.TString;
     privateKey: Type.TString;

package/dist/errors.d.ts

@@ -2,6 +2,8 @@ export declare class ConfigurationNotFoundError extends Error {
 }
 export declare class NotInitializedError extends Error {
 }
+export declare class AccountNotFoundError extends Error {
+}
 export declare class InvalidPrivateKeyError extends Error {
 }
 export declare class AuthorizationRequiredError extends Error {

package/dist/errors.js

@@ -2,6 +2,8 @@ export class ConfigurationNotFoundError extends Error {
 }
 export class NotInitializedError extends Error {
 }
+export class AccountNotFoundError extends Error {
+}
 export class InvalidPrivateKeyError extends Error {
 }
 export class AuthorizationRequiredError extends Error {

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

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

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

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

package/dist/hooks/finally/unlock-config.d.ts

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