@hubspot/cli 8.0.10-experimental.6 → 8.0.10-experimental.7

package/commands/cms/watch.js

@@ -0,0 +1,132 @@
+import fs from 'fs';
+import path from 'path';
+import { watch } from '@hubspot/local-dev-lib/cms/watch';
+import { getCwd } from '@hubspot/local-dev-lib/path';
+import { getCmsPublishMode } from '../../lib/commonOpts.js';
+import { uploadPrompt } from '../../lib/prompts/uploadPrompt.js';
+import { validateCmsPublishMode } from '../../lib/validation.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { commands } from '../../lang/en.js';
+import { getUploadableFileList } from '../../lib/upload.js';
+import { logError, ApiErrorContext } from '../../lib/errorHandlers/index.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+const command = 'watch [src] [dest]';
+const describe = commands.cms.subcommands.watch.describe;
+const handler = async (args) => {
+    const { remove, initialUpload, notify, derivedAccountId } = args;
+    if (!validateCmsPublishMode(args)) {
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const cmsPublishMode = getCmsPublishMode(args);
+    const uploadPromptAnswers = await uploadPrompt(args);
+    const src = args.src || uploadPromptAnswers.src;
+    const dest = args.dest || uploadPromptAnswers.dest;
+    const absoluteSrcPath = path.resolve(getCwd(), src);
+    try {
+        const stats = fs.statSync(absoluteSrcPath);
+        if (!stats.isDirectory()) {
+            uiLogger.log(commands.cms.subcommands.watch.errors.invalidPath(src));
+            return;
+        }
+    }
+    catch (e) {
+        uiLogger.log(commands.cms.subcommands.watch.errors.invalidPath(src));
+        return;
+    }
+    if (!dest) {
+        uiLogger.log(commands.cms.subcommands.watch.errors.destinationRequired);
+        return;
+    }
+    let filesToUpload = [];
+    if (initialUpload) {
+        filesToUpload = await getUploadableFileList(absoluteSrcPath, args.convertFields);
+    }
+    trackCommandUsage('watch', { mode: cmsPublishMode }, derivedAccountId);
+    const onUploadFolderError = (error) => {
+        uiLogger.error(commands.cms.subcommands.watch.errors.folderFailed(src, dest, derivedAccountId));
+        logError(error, {
+            accountId: derivedAccountId,
+        });
+    };
+    const onUploadFileError = (file, destPath, accountId) => (error) => {
+        uiLogger.error(commands.cms.subcommands.watch.errors.fileFailed(file, destPath, accountId));
+        logError(error, new ApiErrorContext({
+            accountId,
+            request: destPath,
+            payload: file,
+        }));
+    };
+    watch(derivedAccountId, absoluteSrcPath, dest, {
+        cmsPublishMode,
+        remove,
+        disableInitial: !initialUpload,
+        notify,
+        commandOptions: args,
+        filePaths: filesToUpload,
+    }, null, onUploadFolderError, undefined, onUploadFileError);
+};
+function watchBuilder(yargs) {
+    yargs.positional('src', {
+        describe: commands.cms.subcommands.watch.positionals.src,
+        type: 'string',
+    });
+    yargs.positional('dest', {
+        describe: commands.cms.subcommands.watch.positionals.dest,
+        type: 'string',
+    });
+    yargs.option('field-options', {
+        describe: commands.cms.subcommands.watch.options.options,
+        type: 'array',
+        default: [''],
+        hidden: true,
+    });
+    yargs.option('remove', {
+        alias: 'r',
+        describe: commands.cms.subcommands.watch.options.remove,
+        type: 'boolean',
+    });
+    yargs.option('initial-upload', {
+        alias: 'i',
+        describe: commands.cms.subcommands.watch.options.initialUpload,
+        type: 'boolean',
+    });
+    // TODO: remove this before the next major release
+    yargs.option('disable-initial', {
+        describe: commands.cms.subcommands.watch.options.disableInitial,
+        type: 'boolean',
+        hidden: true,
+    });
+    yargs.option('notify', {
+        alias: 'n',
+        describe: commands.cms.subcommands.watch.options.notify,
+        type: 'string',
+        requiresArg: true,
+    });
+    yargs.option('convert-fields', {
+        describe: commands.cms.subcommands.watch.options.convertFields,
+        type: 'boolean',
+        default: false,
+    });
+    yargs.option('save-output', {
+        describe: commands.cms.subcommands.watch.options.saveOutput,
+        type: 'boolean',
+        default: false,
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(watchBuilder, command, describe, {
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useGlobalOptions: true,
+    useEnvironmentOptions: true,
+    useCmsPublishModeOptions: { write: true },
+});
+const watchCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default watchCommand;

package/commands/cms/webpack/create.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../../types/Yargs.js';
+type WebpackCreateArgs = CommonArgs & ConfigArgs & {
+    dest?: string;
+};
+declare const webpackCreateCommand: YargsCommandModule<unknown, WebpackCreateArgs>;
+export default webpackCreateCommand;

package/commands/cms/webpack/create.js

@@ -0,0 +1,58 @@
+import fs from 'fs-extra';
+import { logError } from '../../../lib/errorHandlers/index.js';
+import { resolveLocalPath } from '../../../lib/filesystem.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { commands } from '../../../lang/en.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import assets from '../../../lib/cmsAssets/index.js';
+const command = 'create [dest]';
+const describe = commands.cms.subcommands.webpack.subcommands.create.describe;
+async function handler(args) {
+    const { dest, derivedAccountId } = args;
+    const assetType = 'webpack-serverless';
+    trackCommandUsage('create', { assetType }, derivedAccountId);
+    const asset = assets[assetType];
+    const argsToPass = {
+        commandArgs: args,
+        assetType,
+        dest,
+    };
+    if (!argsToPass.dest) {
+        argsToPass.dest = resolveLocalPath(asset.dest(argsToPass));
+    }
+    try {
+        await fs.ensureDir(argsToPass.dest);
+    }
+    catch (e) {
+        uiLogger.error(commands.cms.subcommands.webpack.subcommands.create.errors.unusablePath(argsToPass.dest));
+        logError(e);
+        return;
+    }
+    try {
+        await asset.execute(argsToPass);
+    }
+    catch (e) {
+        logError(e);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+function webpackCreateBuilder(yargs) {
+    yargs.positional('dest', {
+        describe: commands.cms.subcommands.webpack.subcommands.create.positionals.dest,
+        type: 'string',
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(webpackCreateBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+});
+const webpackCreateCommand = {
+    command,
+    describe,
+    builder,
+    handler,
+};
+export default webpackCreateCommand;

package/commands/cms/webpack.d.ts

@@ -0,0 +1,3 @@
+import { YargsCommandModuleBucket } from '../../types/Yargs.js';
+declare const webpackCommand: YargsCommandModuleBucket;
+export default webpackCommand;

package/commands/cms/webpack.js

@@ -0,0 +1,17 @@
+import createCommand from './webpack/create.js';
+import { commands } from '../../lang/en.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+const command = 'webpack';
+const describe = commands.cms.subcommands.webpack.describe;
+function webpackBuilder(yargs) {
+    yargs.command(createCommand).demandCommand(1, '');
+    return yargs;
+}
+const builder = makeYargsBuilder(webpackBuilder, command, describe);
+const webpackCommand = {
+    command,
+    describe,
+    builder,
+    handler: () => { },
+};
+export default webpackCommand;

package/commands/cms.d.ts

@@ -0,0 +1,3 @@
+import { YargsCommandModuleBucket } from '../types/Yargs.js';
+declare const cmsCommand: YargsCommandModuleBucket;
+export default cmsCommand;

package/commands/cms.js

@@ -0,0 +1,49 @@
+import { commands } from '../lang/en.js';
+import { makeYargsBuilder } from '../lib/yargsUtils.js';
+import lighthouseScore from './cms/lighthouseScore.js';
+import convertFields from './cms/convertFields.js';
+import getReactModule from './cms/getReactModule.js';
+import watchCommand from './cms/watch.js';
+import listCommand from './cms/list.js';
+import uploadCommand from './cms/upload.js';
+import fetchCommand from './cms/fetch.js';
+import deleteCommand from './cms/delete.js';
+import mvCommand from './cms/mv.js';
+import functionCommand from './cms/function.js';
+import lintCommand from './cms/lint.js';
+import themeCommand from './cms/theme.js';
+import moduleCommand from './cms/module.js';
+import webpackCommand from './cms/webpack.js';
+import appCommand from './cms/app.js';
+import templateCommand from './cms/template.js';
+const command = 'cms';
+const describe = commands.cms.describe;
+function cmsBuilder(yargs) {
+    yargs
+        .command(lighthouseScore)
+        .command(convertFields)
+        .command(getReactModule)
+        .command(watchCommand)
+        .command(listCommand)
+        .command(uploadCommand)
+        .command(fetchCommand)
+        .command(deleteCommand)
+        .command(mvCommand)
+        .command(functionCommand)
+        .command(lintCommand)
+        .command(themeCommand)
+        .command(moduleCommand)
+        .command(webpackCommand)
+        .command(appCommand)
+        .command(templateCommand)
+        .demandCommand(1, '');
+    return yargs;
+}
+const builder = makeYargsBuilder(cmsBuilder, command, describe);
+const cmsCommand = {
+    command,
+    describe,
+    builder,
+    handler: () => { },
+};
+export default cmsCommand;

package/commands/completion.d.ts

@@ -0,0 +1,3 @@
+import { CommonArgs, YargsCommandModule } from '../types/Yargs.js';
+declare const completionCommand: YargsCommandModule<unknown, CommonArgs>;
+export default completionCommand;

package/commands/completion.js

@@ -0,0 +1,27 @@
+import yargsParser from 'yargs-parser';
+import { commands } from '../lang/en.js';
+import { trackCommandUsage } from '../lib/usageTracking.js';
+import { makeYargsBuilder } from '../lib/yargsUtils.js';
+const command = 'completion';
+const describe = commands.completion.describe;
+async function handler() {
+    await trackCommandUsage('completion');
+}
+function completionBuilder(yargs) {
+    const { help } = yargsParser(process.argv.slice(2));
+    if (!help) {
+        yargs.completion();
+    }
+    yargs.example([
+        ['$0 completion >> ~/.zshrc', commands.completion.examples.default],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(completionBuilder, command, describe);
+const completionCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default completionCommand;

package/commands/config/migrate.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../types/Yargs.js';
+type ConfigMigrateArgs = CommonArgs & ConfigArgs & {
+    force?: boolean;
+};
+declare const configMigrateCommand: YargsCommandModule<unknown, ConfigMigrateArgs>;
+export default configMigrateCommand;

package/commands/config/migrate.js

@@ -0,0 +1,70 @@
+import fs from 'fs';
+import { localConfigFileExists, globalConfigFileExists, } from '@hubspot/local-dev-lib/config';
+import { handleMigration, handleMerge } from '../../lib/configMigrate.js';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { commands } from '../../lang/en.js';
+const describe = commands.config.subcommands.migrate.describe;
+const command = 'migrate';
+async function handler(args) {
+    const { derivedAccountId, config: configPath, force } = args;
+    trackCommandUsage('config-migrate', {}, derivedAccountId);
+    if (configPath && !fs.existsSync(configPath)) {
+        uiLogger.error(commands.config.subcommands.migrate.errors.configNotFound(configPath));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const deprecatedConfigExists = localConfigFileExists();
+    const globalConfigExists = globalConfigFileExists();
+    if (!deprecatedConfigExists) {
+        uiLogger.error(commands.config.subcommands.migrate.errors.noConfigToMigrate);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    let success = false;
+    try {
+        if (!globalConfigExists) {
+            success = await handleMigration(true);
+        }
+        else {
+            success = await handleMerge(force, true);
+        }
+    }
+    catch (error) {
+        logError(error);
+    }
+    process.exit(success ? EXIT_CODES.SUCCESS : EXIT_CODES.ERROR);
+}
+function configMigrateBuilder(yargs) {
+    return yargs
+        .option({
+        force: {
+            alias: 'f',
+            type: 'boolean',
+            default: false,
+            description: commands.config.subcommands.migrate.options.force,
+        },
+    })
+        .example([
+        [
+            '$0 config migrate',
+            commands.config.subcommands.migrate.examples.default,
+        ],
+        [
+            '$0 config migrate --config=/path/to/config.yml',
+            commands.config.subcommands.migrate.examples.configFlag,
+        ],
+    ]);
+}
+const builder = makeYargsBuilder(configMigrateBuilder, command, commands.config.subcommands.migrate.verboseDescribe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+});
+const configMigrateCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default configMigrateCommand;

package/commands/config/set.d.ts

@@ -0,0 +1,11 @@
+import { CmsPublishMode } from '@hubspot/local-dev-lib/types/Files';
+import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../types/Yargs.js';
+type ConfigSetArgs = CommonArgs & ConfigArgs & {
+    defaultCmsPublishMode?: CmsPublishMode;
+    allowUsageTracking?: boolean;
+    httpTimeout?: string;
+    allowAutoUpdates?: boolean;
+    autoOpenBrowser?: boolean;
+};
+declare const configSetCommand: YargsCommandModule<unknown, ConfigSetArgs>;
+export default configSetCommand;

package/commands/config/set.js

@@ -0,0 +1,141 @@
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { promptUser } from '../../lib/prompts/promptUtils.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { setDefaultCmsPublishMode, setHttpTimeout, setAllowUsageTracking, setAllowAutoUpdates, setAutoOpenBrowser, } from '../../lib/configOptions.js';
+import { commands } from '../../lang/en.js';
+import { makeYargsBuilder, strictEnforceBoolean, } from '../../lib/yargsUtils.js';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+const command = 'set';
+const describe = commands.config.subcommands.set.describe;
+async function selectOptions() {
+    const { configOption } = await promptUser([
+        {
+            type: 'list',
+            name: 'configOption',
+            pageSize: 20,
+            message: commands.config.subcommands.set.promptMessage,
+            choices: [
+                {
+                    name: 'Default CMS publish mode',
+                    value: { defaultCmsPublishMode: '' },
+                },
+                { name: 'Allow usage tracking', value: { allowUsageTracking: '' } },
+                { name: 'HTTP timeout', value: { httpTimeout: '' } },
+                { name: 'Allow auto updates', value: { allowAutoUpdates: '' } },
+            ],
+        },
+    ]);
+    return configOption;
+}
+async function handleConfigUpdate(accountId, args) {
+    const { allowAutoUpdates, allowUsageTracking, defaultCmsPublishMode, httpTimeout, autoOpenBrowser, } = args;
+    if (allowAutoUpdates !== undefined) {
+        await setAllowAutoUpdates({ allowAutoUpdates, accountId });
+    }
+    if (allowUsageTracking !== undefined) {
+        await setAllowUsageTracking({ allowUsageTracking, accountId });
+    }
+    if (autoOpenBrowser !== undefined) {
+        await setAutoOpenBrowser({ autoOpenBrowser, accountId });
+    }
+    if (defaultCmsPublishMode !== undefined) {
+        await setDefaultCmsPublishMode({ defaultCmsPublishMode, accountId });
+    }
+    if (httpTimeout !== undefined) {
+        await setHttpTimeout({ httpTimeout, accountId });
+    }
+}
+async function handler(args) {
+    const { derivedAccountId, allowAutoUpdates, allowUsageTracking, defaultCmsPublishMode, httpTimeout, autoOpenBrowser, } = args;
+    trackCommandUsage('config-set', {}, derivedAccountId);
+    try {
+        if (allowAutoUpdates !== undefined ||
+            allowUsageTracking !== undefined ||
+            autoOpenBrowser !== undefined ||
+            defaultCmsPublishMode !== undefined ||
+            httpTimeout !== undefined) {
+            await handleConfigUpdate(derivedAccountId, args);
+        }
+        else {
+            const selectedOptions = await selectOptions();
+            await handleConfigUpdate(derivedAccountId, selectedOptions);
+        }
+    }
+    catch (err) {
+        logError(err);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    process.exit(EXIT_CODES.SUCCESS);
+}
+function configSetBuilder(yargs) {
+    yargs
+        .options({
+        'default-cms-publish-mode': {
+            describe: commands.config.subcommands.set.options.defaultMode.describe,
+            type: 'string',
+            choices: ['draft', 'publish'],
+        },
+        'http-timeout': {
+            describe: commands.config.subcommands.set.options.httpTimeout.describe,
+            type: 'number',
+            coerce: (value) => {
+                if (isNaN(value) || value < 3000) {
+                    uiLogger.error(commands.config.subcommands.set.errors.invalidHTTPTimeout);
+                    process.exit(EXIT_CODES.ERROR);
+                }
+                return value;
+            },
+        },
+        'allow-usage-tracking': {
+            describe: commands.config.subcommands.set.options.allowUsageTracking.describe,
+            type: 'boolean',
+        },
+        'allow-auto-updates': {
+            describe: commands.config.subcommands.set.options.allowAutoUpdates.describe,
+            type: 'boolean',
+        },
+        'auto-open-browser': {
+            describe: commands.config.subcommands.set.options.autoOpenBrowser.describe,
+            type: 'boolean',
+        },
+    })
+        .check(() => {
+        // Use process.argv directly because yargs argv has already been parsed/coerced,
+        // but we need to validate the exact format the user provided (e.g., --flag=true vs --flag)
+        return strictEnforceBoolean(process.argv, [
+            'allow-usage-tracking',
+            'allow-auto-updates',
+            'auto-open-browser',
+        ]);
+    })
+        .example([
+        ['$0 config set', commands.config.subcommands.set.examples.default],
+        ['$0 config set --allow-usage-tracking=false', 'Disable usage tracking'],
+        ['$0 config set --http-timeout=5000', 'Set HTTP timeout to 5000ms'],
+        [
+            '$0 config set --default-cms-publish-mode=draft',
+            'Set default CMS publish mode to draft',
+        ],
+        [
+            '$0 config set --http-timeout=3000 --allow-usage-tracking=false',
+            'Set HTTP timeout and disable usage tracking',
+        ],
+        [
+            '$0 config set --default-cms-publish-mode=draft --http-timeout=4000 --allow-usage-tracking=true',
+            'Configure multiple settings at once',
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(configSetBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+});
+const configSetCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default configSetCommand;

package/commands/config.d.ts

@@ -0,0 +1,3 @@
+import { YargsCommandModuleBucket } from '../types/Yargs.js';
+declare const configCommand: YargsCommandModuleBucket;
+export default configCommand;

package/commands/config.js

@@ -0,0 +1,18 @@
+import { commands } from '../lang/en.js';
+import set from './config/set.js';
+import migrate from './config/migrate.js';
+import { makeYargsBuilder } from '../lib/yargsUtils.js';
+const command = 'config';
+const describe = commands.config.describe;
+function configBuilder(yargs) {
+    yargs.command(set).command(migrate).demandCommand(1, '');
+    return yargs;
+}
+const builder = makeYargsBuilder(configBuilder, command, describe);
+const configCommand = {
+    command,
+    describe,
+    builder,
+    handler: () => { },
+};
+export default configCommand;

package/commands/customObject/create.d.ts

@@ -0,0 +1,7 @@
+import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, YargsCommandModule } from '../../types/Yargs.js';
+type CustomObjectCreateArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
+    name?: string;
+    path?: string;
+};
+declare const customObjectCreateCommand: YargsCommandModule<unknown, CustomObjectCreateArgs>;
+export default customObjectCreateCommand;

package/commands/customObject/create.js

@@ -0,0 +1,64 @@
+import { uiLogger } from '../../lib/ui/logger.js';
+import { batchCreateObjects } from '@hubspot/local-dev-lib/api/customObjects';
+import { inputPrompt } from '../../lib/prompts/promptUtils.js';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { getAbsoluteFilePath } from '@hubspot/local-dev-lib/path';
+import { checkAndConvertToJson } from '../../lib/validation.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { commands } from '../../lang/en.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { isObjectDefinition } from '../../lib/customObject.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+const command = 'create [name]';
+const describe = commands.customObject.subcommands.create.describe;
+async function handler(args) {
+    const { path, name: providedName, derivedAccountId } = args;
+    let definitionPath = path;
+    let name = providedName;
+    trackCommandUsage('custom-object-batch-create', {}, derivedAccountId);
+    if (!name) {
+        name = await inputPrompt(commands.customObject.subcommands.create.inputName);
+    }
+    if (!definitionPath) {
+        definitionPath = await inputPrompt(commands.customObject.subcommands.create.inputPath);
+    }
+    const filePath = getAbsoluteFilePath(definitionPath);
+    const objectJson = checkAndConvertToJson(filePath);
+    if (!isObjectDefinition(objectJson)) {
+        uiLogger.error(commands.customObject.subcommands.create.errors.invalidObjectDefinition);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    try {
+        await batchCreateObjects(derivedAccountId, name, objectJson);
+        uiLogger.success(commands.customObject.subcommands.create.success.objectsCreated);
+    }
+    catch (e) {
+        logError(e, { accountId: derivedAccountId });
+        uiLogger.error(commands.customObject.subcommands.create.errors.creationFailed(definitionPath));
+    }
+}
+function customObjectCreateBuilder(yargs) {
+    yargs
+        .positional('name', {
+        describe: commands.customObject.subcommands.create.positionals.name.describe,
+        type: 'string',
+    })
+        .option('path', {
+        describe: commands.customObject.subcommands.create.options.path.describe,
+        type: 'string',
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(customObjectCreateBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+});
+const customObjectCreateCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default customObjectCreateCommand;

package/commands/customObject/createSchema.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, TestingArgs, YargsCommandModule } from '../../types/Yargs.js';
+export type SchemaCreateArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & TestingArgs & {
+    path: string;
+};
+declare const createSchemaCommand: YargsCommandModule<unknown, SchemaCreateArgs>;
+export default createSchemaCommand;