@swell/cli 2.2.0 → 2.3.0

package/dist/create-app-command.js

@@ -13,24 +13,26 @@ import style from './lib/style.js';
 import { SwellCommand } from './swell-command.js';
 const execAsync = promisify(exec);
 export class CreateAppCommand extends SwellCommand {
+    // Command name used in error message examples; override in subclasses
+    commandExample = 'swell create app';
     static baseFlags = {
         frontend: Flags.string({
-            description: `create a starter framework for a hosted frontend (default in -y: none)`,
+            description: 'Framework: astro | angular | hono | nuxt | nextjs | none',
             options: getFrontendProjectSlugs(true, false),
         }),
         'storefront-app': Flags.string({
-            description: `id of an installed storefront app to create a theme for, if applicable`,
+            description: 'Target storefront app ID',
         }),
         'integration-type': Flags.string({
-            description: `integration type for integration app, if applicable`,
+            description: 'Integration: generic | payment | shipping | tax',
             options: ['generic', 'payment', 'shipping', 'tax'],
         }),
         'integration-id': Flags.string({
-            description: `unique identifier for the integration service (required for payment/shipping/tax; use 'card' for credit cards)`,
+            description: 'Service ID (e.g., card, fedex)',
         }),
         yes: Flags.boolean({
             char: 'y',
-            description: `accept all default values; non-interactive, never prompts; errors if required values are missing`,
+            description: 'Skip prompts, require all arguments',
         }),
     };
     devApi;
@@ -354,12 +356,12 @@ export class CreateAppCommand extends SwellCommand {
     getProjectType(frameworkType) {
         const projectType = FrontendProjectTypes.find((type) => type.slug === frameworkType);
         if (!projectType) {
-            this.error(`Could not find project type: ${frameworkType}\n\nValid values: ${getFrontendProjectValidValues(true, false)}\n\nExample: swell create app reviews --type admin --frontend astro -y`, {
+            this.error(`Could not find project type: ${frameworkType}\n\nValid values: ${getFrontendProjectValidValues(true, false)}\n\nExample: ${this.commandExample} reviews --type admin --frontend astro -y`, {
                 exit: 1,
             });
         }
         if (!projectType.installCommand) {
-            this.error(`Project type ${projectType.name} cannot be installed (legacy type)\n\nValid values: ${getFrontendProjectValidValues(true, false)}\n\nExample: swell create app reviews --type admin --frontend astro -y`, {
+            this.error(`Project type ${projectType.name} cannot be installed (legacy type)\n\nValid values: ${getFrontendProjectValidValues(true, false)}\n\nExample: ${this.commandExample} reviews --type admin --frontend astro -y`, {
                 exit: 1,
             });
         }
@@ -378,9 +380,12 @@ export class CreateAppCommand extends SwellCommand {
             workspaces: ['frontend'],
             devDependencies: {
                 '@swell/app-types': '^1.0.5',
+                typescript: '^5.9.3',
             },
             name,
-            scripts: {},
+            scripts: {
+                typecheck: '([ -z "$(find functions -name \'*.ts\' 2>/dev/null | head -1)" ] || tsc --noEmit) && ([ ! -f test/tsconfig.json ] || tsc --noEmit -p test) && ([ ! -f frontend/tsconfig.json ] || tsc --noEmit -p frontend)',
+            },
             version: config.get('version'),
         };
         const tsConfig = {
@@ -388,10 +393,10 @@ export class CreateAppCommand extends SwellCommand {
                 lib: ['esnext', 'webworker'],
                 module: 'esnext',
                 target: 'esnext',
+                moduleResolution: 'bundler',
                 types: ['@swell/app-types'],
             },
-            exclude: ['node_modules', 'frontend'],
-            include: ['**/*.ts'],
+            exclude: ['node_modules', 'frontend', 'test', 'vitest.config.ts'],
         };
         await writeJsonFile(path.join(configPath, 'package.json'), packageJson);
         await writeJsonFile(path.join(configPath, 'tsconfig.json'), tsConfig);

package/dist/create-config-command.js

@@ -1,7 +1,7 @@
 import { confirm } from '@inquirer/prompts';
 import * as path from 'node:path';
 import { AppCommand } from './app-command.js';
-import { ConfigPaths, filePathExists, writeFile, writeJsonFile, } from './lib/apps/index.js';
+import { AllConfigPaths, filePathExists, writeFile, writeJsonFile, } from './lib/apps/index.js';
 /**
  * A base class for Swell CLI Create commands for file and input handling.
  *
@@ -14,7 +14,7 @@ export class CreateConfigCommand extends AppCommand {
     createType = '';
     async createFile({ extension = 'json', fileBody, fileName }, overwrite, shouldConfirm = true) {
         const isJson = extension === 'json';
-        const filePath = path.join(this.appPath, ConfigPaths[this.createType.toUpperCase()], `${fileName}.${extension}`);
+        const filePath = path.join(this.appPath, AllConfigPaths[this.createType.toUpperCase()], `${fileName}.${extension}`);
         if (shouldConfirm) {
             this.log(`\nCreating app ${this.createType} in ${filePath}`);
             this.log(`\n${isJson ? JSON.stringify(fileBody, null, 4) : fileBody}\n`);

package/dist/help/custom-help.d.ts

@@ -0,0 +1,89 @@
+import { Command, Help } from '@oclif/core';
+/**
+ * Custom Help class for Swell CLI
+ *
+ * Renders help in a cleaner format with:
+ * - Two-line USAGE with "# interactive" comment
+ * - Grouped flags by category (type options vs general)
+ * - Custom sections for conditional dependencies (TYPE OPTIONS, APP TYPES, etc.)
+ *
+ * Commands opt-in to custom formatting by defining a static `helpMeta` property.
+ * Commands without helpMeta use standard oclif formatting.
+ */
+export default class CustomHelp extends Help {
+    /**
+     * Override showCommandHelp to prevent duplicate summary for commands with helpMeta.
+     * The default implementation logs summary separately, but our formatCommand includes it.
+     * @param command - The command to display help for
+     * @returns Promise that resolves when help is displayed
+     */
+    showCommandHelp(command: Command.Loadable): Promise<void>;
+    /**
+     * Override formatCommand to provide custom help output for commands with helpMeta.
+     * Falls back to default formatting for commands without helpMeta.
+     * @param command - The command to format help for
+     * @returns Formatted help text as a string
+     */
+    protected formatCommand(command: Command.Loadable): string;
+    /**
+     * Get helpMeta from a command, handling the Command.Loadable type.
+     * The helpMeta is stored on the command class itself, accessible via the cached command.
+     * @param command - The command to extract helpMeta from
+     * @returns The helpMeta object if present on the command, otherwise undefined
+     */
+    private getHelpMeta;
+    /**
+     * Format USAGE section with two-line pattern:
+     * - Line 1: Interactive mode (no args) with "# interactive" comment
+     * - Line 2: Direct/non-interactive mode with args
+     * @param command - The command to format usage for
+     * @param helpMeta - The help metadata for the command
+     * @returns Formatted USAGE section as an array of strings
+     */
+    private formatUsageSection;
+    /**
+     * Auto-generate direct usage line from command definition.
+     * @param command - The command to generate direct usage for
+     * @returns The generated direct usage line as a string
+     */
+    private generateDirectUsage;
+    /**
+     * Format ARGUMENTS section with compact display.
+     * @param command - The command to format arguments for
+     * @returns Formatted ARGUMENTS section as an array of strings
+     */
+    private formatArgumentsSection;
+    /**
+     * Format TYPE section (APP TYPES, etc.) with requires/optional indicators.
+     * @param section - The type section configuration with types and their requirements
+     * @returns Formatted TYPE section as an array of strings
+     */
+    private formatTypeSection;
+    /**
+     * Format VARIANT section (TRIGGER OPTIONS, etc.) - compact inline format.
+     * @param section - The variant section configuration with variants and their descriptions
+     * @returns Formatted VARIANT section as an array of strings
+     */
+    private formatVariantSection;
+    /**
+     * Format FLAGS section with filtering and sorting.
+     * @param command - The command to format flags for
+     * @param title - The section title to display
+     * @param filter - Function to filter flags by name
+     * @returns Formatted FLAGS section as an array of strings
+     */
+    private formatFlagsSection;
+    /**
+     * Format DESCRIPTION section - shows description if it differs from summary.
+     * Only shown when there's meaningful additional content.
+     * @param command - The command to format description for
+     * @returns Formatted DESCRIPTION section as an array of strings
+     */
+    private formatDescriptionSection;
+    /**
+     * Format EXAMPLES section - clean, label-free examples.
+     * @param command - The command to format examples for
+     * @returns Formatted EXAMPLES section as an array of strings
+     */
+    private formatExamplesSection;
+}

package/dist/help/custom-help.js

@@ -0,0 +1,337 @@
+import { Help } from '@oclif/core';
+/**
+ * Custom Help class for Swell CLI
+ *
+ * Renders help in a cleaner format with:
+ * - Two-line USAGE with "# interactive" comment
+ * - Grouped flags by category (type options vs general)
+ * - Custom sections for conditional dependencies (TYPE OPTIONS, APP TYPES, etc.)
+ *
+ * Commands opt-in to custom formatting by defining a static `helpMeta` property.
+ * Commands without helpMeta use standard oclif formatting.
+ */
+export default class CustomHelp extends Help {
+    /**
+     * Override showCommandHelp to prevent duplicate summary for commands with helpMeta.
+     * The default implementation logs summary separately, but our formatCommand includes it.
+     * @param command - The command to display help for
+     * @returns Promise that resolves when help is displayed
+     */
+    async showCommandHelp(command) {
+        const helpMeta = this.getHelpMeta(command);
+        if (helpMeta) {
+            // For commands with helpMeta, just log formatCommand output
+            // (which includes the description/summary already)
+            this.log(this.formatCommand(command));
+        }
+        else {
+            // For commands without helpMeta, use default behavior
+            await super.showCommandHelp(command);
+        }
+    }
+    /**
+     * Override formatCommand to provide custom help output for commands with helpMeta.
+     * Falls back to default formatting for commands without helpMeta.
+     * @param command - The command to format help for
+     * @returns Formatted help text as a string
+     */
+    formatCommand(command) {
+        const helpMeta = this.getHelpMeta(command);
+        // No helpMeta - use default oclif formatting
+        if (!helpMeta) {
+            return super.formatCommand(command);
+        }
+        // Custom formatting for commands with helpMeta
+        const lines = [];
+        // Description (single line) - use summary if available, else first line of description
+        const desc = command.summary || command.description?.split('\n')[0];
+        if (desc) {
+            lines.push(desc, '');
+        }
+        // USAGE section
+        lines.push(...this.formatUsageSection(command, helpMeta));
+        // ARGUMENTS section
+        const argsSection = this.formatArgumentsSection(command);
+        if (argsSection.length > 0) {
+            lines.push('', ...argsSection);
+        }
+        // TYPE SECTION (e.g., APP TYPES) - for commands with type-based conditional deps
+        if (helpMeta.typeSection) {
+            lines.push('', ...this.formatTypeSection(helpMeta.typeSection));
+        }
+        // VARIANT SECTION (e.g., TRIGGER OPTIONS) - for simpler variant-based deps
+        if (helpMeta.variantSection) {
+            lines.push('', ...this.formatVariantSection(helpMeta.variantSection));
+        }
+        // TYPE-SPECIFIC FLAGS (when using typeSection)
+        if (helpMeta.typeFlags && helpMeta.typeFlags.length > 0) {
+            const typeSpecificFlags = this.formatFlagsSection(command, 'TYPE OPTIONS', (name) => helpMeta.typeFlags.includes(name));
+            if (typeSpecificFlags.length > 0) {
+                lines.push('', ...typeSpecificFlags);
+            }
+        }
+        // GENERAL FLAGS section
+        const excludeFlags = new Set([
+            ...(helpMeta.variantFlags || []),
+            ...(helpMeta.typeFlags || []),
+        ]);
+        const flagsSection = this.formatFlagsSection(command, 'FLAGS', (name) => !excludeFlags.has(name));
+        if (flagsSection.length > 0) {
+            lines.push('', ...flagsSection);
+        }
+        // DESCRIPTION section (if description differs from summary)
+        const descSection = this.formatDescriptionSection(command);
+        if (descSection.length > 0) {
+            lines.push('', ...descSection);
+        }
+        // EXAMPLES section
+        const examplesSection = this.formatExamplesSection(command);
+        if (examplesSection.length > 0) {
+            lines.push('', ...examplesSection);
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Get helpMeta from a command, handling the Command.Loadable type.
+     * The helpMeta is stored on the command class itself, accessible via the cached command.
+     * @param command - The command to extract helpMeta from
+     * @returns The helpMeta object if present on the command, otherwise undefined
+     */
+    getHelpMeta(command) {
+        // Command.Loadable stores all static properties on the object itself
+        // We need to cast to access the helpMeta property
+        return command.helpMeta;
+    }
+    /**
+     * Format USAGE section with two-line pattern:
+     * - Line 1: Interactive mode (no args) with "# interactive" comment
+     * - Line 2: Direct/non-interactive mode with args
+     * @param command - The command to format usage for
+     * @param helpMeta - The help metadata for the command
+     * @returns Formatted USAGE section as an array of strings
+     */
+    formatUsageSection(command, helpMeta) {
+        const lines = ['USAGE'];
+        // Convert colon separator to space (e.g., "create:app" -> "create app")
+        const cmdId = command.id.replaceAll(':', ' ');
+        // First line: interactive (no args)
+        const interactiveLine = `  $ swell ${cmdId}`;
+        const padding = Math.max(50 - interactiveLine.length, 2);
+        lines.push(`${interactiveLine}${' '.repeat(padding)}# interactive`);
+        // Second line: direct mode with args
+        if (helpMeta.usageDirect) {
+            lines.push(`  $ swell ${cmdId} ${helpMeta.usageDirect}`);
+        }
+        else {
+            // Auto-generate from args and flags
+            const directLine = this.generateDirectUsage(command);
+            if (directLine !== interactiveLine) {
+                lines.push(directLine);
+            }
+        }
+        return lines;
+    }
+    /**
+     * Auto-generate direct usage line from command definition.
+     * @param command - The command to generate direct usage for
+     * @returns The generated direct usage line as a string
+     */
+    generateDirectUsage(command) {
+        const cmdId = command.id.replaceAll(':', ' ');
+        const parts = [`  $ swell ${cmdId}`];
+        // Add args
+        if (command.args) {
+            const argEntries = Object.entries(command.args);
+            for (const [name] of argEntries) {
+                parts.push(`<${name.toLowerCase()}>`);
+            }
+        }
+        // Check if there are any optional flags
+        const flags = command.flags || {};
+        const hasOptionalFlags = Object.keys(flags).some((f) => f !== 'yes' && f !== 'help');
+        if (hasOptionalFlags) {
+            parts.push('[...]');
+        }
+        // Add -y if the command has it
+        if (flags.yes) {
+            parts.push('-y');
+        }
+        return parts.join(' ');
+    }
+    /**
+     * Format ARGUMENTS section with compact display.
+     * @param command - The command to format arguments for
+     * @returns Formatted ARGUMENTS section as an array of strings
+     */
+    formatArgumentsSection(command) {
+        if (!command.args || Object.keys(command.args).length === 0) {
+            return [];
+        }
+        const lines = ['ARGUMENTS'];
+        const argEntries = Object.entries(command.args);
+        // Calculate padding for alignment
+        const maxNameLength = Math.max(...argEntries.map(([name]) => name.length));
+        const padding = Math.max(maxNameLength + 4, 8);
+        for (const [name, arg] of argEntries) {
+            const argName = name.toUpperCase();
+            const desc = arg.description || '';
+            lines.push(`  ${argName.padEnd(padding)}${desc}`);
+        }
+        return lines;
+    }
+    /**
+     * Format TYPE section (APP TYPES, etc.) with requires/optional indicators.
+     * @param section - The type section configuration with types and their requirements
+     * @returns Formatted TYPE section as an array of strings
+     */
+    formatTypeSection(section) {
+        if (!section)
+            return [];
+        const lines = [section.title];
+        for (let i = 0; i < section.types.length; i++) {
+            const type = section.types[i];
+            lines.push(`  ${type.name.padEnd(12)} ${type.description}`);
+            if (type.requires) {
+                for (const req of type.requires) {
+                    lines.push(`${''.padEnd(15)}Requires: ${req}`);
+                }
+            }
+            if (type.optional) {
+                for (const opt of type.optional) {
+                    lines.push(`${''.padEnd(15)}Optional: ${opt}`);
+                }
+            }
+            // Add blank line between types for readability (except last)
+            if (i < section.types.length - 1) {
+                lines.push('');
+            }
+        }
+        return lines;
+    }
+    /**
+     * Format VARIANT section (TRIGGER OPTIONS, etc.) - compact inline format.
+     * @param section - The variant section configuration with variants and their descriptions
+     * @returns Formatted VARIANT section as an array of strings
+     */
+    formatVariantSection(section) {
+        if (!section)
+            return [];
+        const lines = [section.title];
+        for (const variant of section.variants) {
+            // Format: "  model    -e, --events=<value>    Description"
+            const flagPart = variant.flag.padEnd(28);
+            lines.push(`  ${variant.name.padEnd(8)} ${flagPart} ${variant.description}`);
+        }
+        return lines;
+    }
+    /**
+     * Format FLAGS section with filtering and sorting.
+     * @param command - The command to format flags for
+     * @param title - The section title to display
+     * @param filter - Function to filter flags by name
+     * @returns Formatted FLAGS section as an array of strings
+     */
+    formatFlagsSection(command, title, filter) {
+        if (!command.flags) {
+            return [];
+        }
+        const flagEntries = Object.entries(command.flags).filter(([name, flag]) => filter(name) && name !== 'help' && !flag.hidden);
+        if (flagEntries.length === 0) {
+            return [];
+        }
+        const lines = [title];
+        // Sort flags: short flags first, then long-only flags, -y last
+        flagEntries.sort(([aName, aFlag], [bName, bFlag]) => {
+            // -y always last
+            if (aName === 'yes')
+                return 1;
+            if (bName === 'yes')
+                return -1;
+            // Flags with short char before flags without
+            const aHasChar = Boolean(aFlag.char);
+            const bHasChar = Boolean(bFlag.char);
+            if (aHasChar && !bHasChar)
+                return -1;
+            if (!aHasChar && bHasChar)
+                return 1;
+            // Alphabetical
+            return aName.localeCompare(bName);
+        });
+        for (const [name, flag] of flagEntries) {
+            const shortChar = flag.char ? `-${flag.char}, ` : '    ';
+            const longFlag = `--${name}`;
+            const isBoolean = flag.type === 'boolean';
+            const hasOptions = 'options' in flag && flag.options;
+            const valueStr = isBoolean ? '' : hasOptions ? '=<option>' : '=<value>';
+            const flagStr = `${shortChar}${longFlag}${valueStr}`;
+            // Get description, clean up redundant "(required in -y)" text
+            let desc = flag.summary || flag.description || '';
+            desc = desc
+                .replaceAll(/\s*\(required (?:with|in) -y\)/gi, '')
+                .replaceAll(/\s*\(required for .+ with -y\)/gi, '')
+                .replaceAll(/\s*\(default in -y: .+\)/gi, '')
+                .split('\n')[0]
+                .trim();
+            lines.push(`  ${flagStr.padEnd(30)} ${desc}`);
+        }
+        return lines;
+    }
+    /**
+     * Format DESCRIPTION section - shows description if it differs from summary.
+     * Only shown when there's meaningful additional content.
+     * @param command - The command to format description for
+     * @returns Formatted DESCRIPTION section as an array of strings
+     */
+    formatDescriptionSection(command) {
+        // Get description (may be multi-line)
+        const { description } = command;
+        if (!description) {
+            return [];
+        }
+        // Skip if description equals summary (no additional info)
+        const summary = command.summary || description.split('\n')[0];
+        if (description === summary) {
+            return [];
+        }
+        const lines = ['DESCRIPTION'];
+        // Format each line of description with proper indentation
+        const descLines = description.split('\n');
+        for (const line of descLines) {
+            lines.push(`  ${line}`);
+        }
+        return lines;
+    }
+    /**
+     * Format EXAMPLES section - clean, label-free examples.
+     * @param command - The command to format examples for
+     * @returns Formatted EXAMPLES section as an array of strings
+     */
+    formatExamplesSection(command) {
+        if (!command.examples || command.examples.length === 0) {
+            return [];
+        }
+        const lines = ['EXAMPLES'];
+        for (const example of command.examples) {
+            if (typeof example === 'string') {
+                // String example - check if it's a command
+                if (example.trim().startsWith('$')) {
+                    lines.push(`  ${example.trim()}`);
+                }
+                else if (example.includes('<%= command.id %>')) {
+                    // oclif template syntax
+                    const cmd = example.replace('<%= command.id %>', command.id);
+                    lines.push(`  $ swell ${cmd.trim()}`);
+                }
+                // Skip description-only lines
+            }
+            else if (typeof example === 'object' && example.command) {
+                // Object example with command property
+                const cmd = example.command.startsWith('swell ')
+                    ? example.command
+                    : `swell ${example.command}`;
+                lines.push(`  $ ${cmd}`);
+            }
+        }
+        return lines;
+    }
+}

package/dist/help/types.d.ts

@@ -0,0 +1,75 @@
+import { Command } from '@oclif/core';
+/**
+ * Represents a type variant with conditional flag requirements.
+ * Used for complex commands like `create app` where different types
+ * have different required/optional flags.
+ */
+export interface TypeVariant {
+    /** Type name (e.g., 'admin', 'theme', 'integration') */
+    name: string;
+    /** Short description of what this type does */
+    description: string;
+    /** Flags required when using this type */
+    requires?: string[];
+    /** Flags optionally available for this type */
+    optional?: string[];
+}
+/**
+ * Represents a simpler variant option where one argument maps to one flag.
+ * Used for commands like `create function` where trigger type determines the flag.
+ */
+export interface VariantOption {
+    /** Variant name (e.g., 'model', 'cron', 'route') */
+    name: string;
+    /** Flag signature (e.g., '-e, --events=<value>') */
+    flag: string;
+    /** Description of what this flag does */
+    description: string;
+}
+/**
+ * Metadata for custom help formatting.
+ * Add this as a static property on commands that need enhanced help output.
+ */
+export interface HelpMeta {
+    /**
+     * Custom usage line for direct/non-interactive mode.
+     * Example: '<id> -t <type> [...] -y'
+     */
+    usageDirect?: string;
+    /**
+     * Type section for complex conditional dependencies.
+     * Renders as a detailed breakdown showing each type with its requirements.
+     */
+    typeSection?: {
+        /** Section title (e.g., 'APP TYPES') */
+        title: string;
+        /** List of type variants */
+        types: TypeVariant[];
+    };
+    /**
+     * Flags to group into a separate "TYPE OPTIONS" section.
+     * These are excluded from the general FLAGS section.
+     */
+    typeFlags?: string[];
+    /**
+     * Variant section for simpler conditional dependencies.
+     * Renders as a compact table: variant -> flag -> description
+     */
+    variantSection?: {
+        /** Section title (e.g., 'TRIGGER OPTIONS') */
+        title: string;
+        /** List of variant options */
+        variants: VariantOption[];
+    };
+    /**
+     * Flags to exclude from the general FLAGS section when using variantSection.
+     */
+    variantFlags?: string[];
+}
+/**
+ * Command class with optional helpMeta static property.
+ * Uses Command.Cached since that's what Help receives from Command.Loadable.
+ */
+export type CommandClassWithMeta = Command.Cached & {
+    helpMeta?: HelpMeta;
+};

package/dist/help/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/apps/app-config.js

@@ -4,7 +4,7 @@ import { detectFilenameMime } from 'mime-detect';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { bundleFunction } from '../bundle.js';
-import { ConfigPaths, ConfigType, filePathExists, hashFile, } from './index.js';
+import { AllConfigPaths, ConfigType, filePathExists, hashFile, } from './index.js';
 export class IgnoringFileError extends Error {
     constructor(message) {
         super(message);
@@ -68,7 +68,7 @@ export class AppConfig {
             }
             else {
                 // Note this shouldn't be necessary unless the config was created before file_path was added
-                const typePath = ConfigPaths[String(type).toUpperCase()];
+                const typePath = AllConfigPaths[String(type).toUpperCase()];
                 filePath = `${typePath}/${name}`;
                 if (!typePath) {
                     throw new Error(`Missing path for app config type: ${type}`);

package/dist/lib/apps/index.d.ts

@@ -106,7 +106,8 @@ export declare const ThemeConfigTypes: ConfigTypeKey[];
 export type ConfigPathsType = {
     [key in ConfigTypeKey]: string;
 };
-export declare const ConfigPaths: ConfigPathsType;
+export declare const AllConfigPaths: ConfigPathsType;
+export declare const StandardConfigPaths: ConfigPathsType;
 export declare const StorefrontConfigPaths: ConfigPathsType;
 export declare const ThemeConfigPaths: ConfigPathsType;
 export declare enum ConfigInputFields {