@gaberoo/kalshitools 1.0.0

package/dist/commands/orders/create.js

@@ -0,0 +1,211 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { BaseCommand } from '../../lib/base-command.js';
+import { getConfig } from '../../lib/config/manager.js';
+import { ValidationError } from '../../lib/errors/base.js';
+import { createClientFromConfig } from '../../lib/kalshi/index.js';
+import { logger } from '../../lib/logger.js';
+import { estimateOrderCost, validateAction, validateOrderType, validatePrice, validateQuantity, validateSide, validateTicker, } from '../../lib/validation.js';
+export default class OrdersCreate extends BaseCommand {
+    static description = 'Create a new order (buy or sell contracts)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --ticker TICKER --action buy --side yes --quantity 10 --type market',
+        '<%= config.bin %> <%= command.id %> --ticker TICKER --action buy --side yes --quantity 10 --type limit --price 0.65',
+        '<%= config.bin %> <%= command.id %> --ticker TICKER --action sell --side no --quantity 5 --type market --yes',
+        '<%= config.bin %> <%= command.id %> --ticker TICKER --action buy --side yes --quantity 100 --dry-run',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        ticker: Flags.string({
+            char: 't',
+            description: 'Market ticker symbol',
+            required: true,
+        }),
+        action: Flags.string({
+            char: 'a',
+            description: 'Order action (buy or sell)',
+            options: ['buy', 'sell'],
+            required: true,
+        }),
+        side: Flags.string({
+            char: 's',
+            description: 'Contract side (yes or no)',
+            options: ['yes', 'no'],
+            required: true,
+        }),
+        quantity: Flags.integer({
+            char: 'q',
+            description: 'Number of contracts',
+            required: true,
+        }),
+        type: Flags.string({
+            description: 'Order type (market or limit)',
+            options: ['market', 'limit'],
+            default: 'market',
+        }),
+        price: Flags.string({
+            char: 'p',
+            description: 'Limit price (required for limit orders, 0.01-0.99)',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip confirmation prompt',
+            default: false,
+        }),
+        'dry-run': Flags.boolean({
+            description: 'Simulate the order without actually placing it',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(OrdersCreate);
+        const configManager = getConfig();
+        const tradingConfig = configManager.getTradingConfig();
+        const environment = configManager.getEnvironment();
+        try {
+            // Validate inputs
+            validateTicker(flags.ticker);
+            const action = validateAction(flags.action);
+            const side = validateSide(flags.side);
+            const orderType = validateOrderType(flags.type);
+            validateQuantity(flags.quantity, tradingConfig.maxOrderSize);
+            let price;
+            if (orderType === 'limit') {
+                if (!flags.price) {
+                    throw new ValidationError('Price is required for limit orders');
+                }
+                price = Number.parseFloat(flags.price);
+                if (Number.isNaN(price)) {
+                    throw new ValidationError('Price must be a valid number', { price: flags.price });
+                }
+                validatePrice(price);
+            }
+            // Estimate cost
+            const costEstimate = estimateOrderCost(side, action, flags.quantity, price);
+            // Build order request
+            const orderRequest = {
+                ticker: flags.ticker,
+                side,
+                action,
+                count: flags.quantity,
+                type: orderType,
+            };
+            if (orderType === 'limit' && price) {
+                if (side === 'yes') {
+                    orderRequest.yes_price = price;
+                }
+                else {
+                    orderRequest.no_price = price;
+                }
+            }
+            // Display order summary
+            if (!this.formatter.isJSONMode()) {
+                this.log();
+                this.log(chalk.cyan.bold('Order Summary'));
+                this.log(chalk.gray('─'.repeat(50)));
+                this.log(`${chalk.cyan('Environment:')} ${environment === 'demo' ? chalk.yellow('DEMO') : chalk.red('PRODUCTION')}`);
+                this.log(`${chalk.cyan('Ticker:')} ${flags.ticker}`);
+                this.log(`${chalk.cyan('Action:')} ${action.toUpperCase()}`);
+                this.log(`${chalk.cyan('Side:')} ${side.toUpperCase()}`);
+                this.log(`${chalk.cyan('Quantity:')} ${flags.quantity}`);
+                this.log(`${chalk.cyan('Type:')} ${orderType.toUpperCase()}`);
+                if (price) {
+                    this.log(`${chalk.cyan('Price:')} ${price.toFixed(2)}`);
+                }
+                this.log();
+                if (action === 'buy') {
+                    this.log(`${chalk.cyan('Estimated Cost:')} $${costEstimate.estimate.toFixed(2)}`);
+                    if (orderType === 'market') {
+                        this.log(chalk.gray(`  (Range: $${costEstimate.min.toFixed(2)} - $${costEstimate.max.toFixed(2)})`));
+                    }
+                }
+                else {
+                    this.log(`${chalk.cyan('Estimated Proceeds:')} $${costEstimate.estimate.toFixed(2)}`);
+                    if (orderType === 'market') {
+                        this.log(chalk.gray(`  (Range: $${costEstimate.min.toFixed(2)} - $${costEstimate.max.toFixed(2)})`));
+                    }
+                }
+                this.log(chalk.gray('─'.repeat(50)));
+                this.log();
+            }
+            // Dry run mode
+            if (flags['dry-run']) {
+                if (this.formatter.isJSONMode()) {
+                    this.formatter.success({
+                        dryRun: true,
+                        order: orderRequest,
+                        costEstimate,
+                    });
+                }
+                else {
+                    this.log(chalk.yellow('DRY RUN - Order not placed'));
+                    this.log(chalk.gray('Order would be submitted with the parameters above'));
+                }
+                logger.info({ orderRequest, dryRun: true }, 'Dry run order');
+                return;
+            }
+            // Confirmation prompt (unless --yes flag or JSON mode)
+            if (tradingConfig.confirmations && !flags.yes && !this.formatter.isJSONMode()) {
+                const confirmed = await this.confirm(environment === 'production'
+                    ? chalk.red.bold('⚠️  This will place a REAL order with REAL money. Continue?')
+                    : 'Place this order?');
+                if (!confirmed) {
+                    this.log(chalk.yellow('Order cancelled'));
+                    return;
+                }
+            }
+            // Create API client and place order
+            const client = createClientFromConfig();
+            const order = await client.createOrder(orderRequest);
+            if (this.formatter.isJSONMode()) {
+                this.formatter.success(order);
+            }
+            else {
+                this.log(chalk.green('✓ Order placed successfully!'));
+                this.log();
+                this.log(`${chalk.cyan('Order ID:')} ${order.order_id}`);
+                this.log(`${chalk.cyan('Status:')} ${this.formatStatus(order.status)}`);
+                this.log(`${chalk.cyan('Filled:')} ${order.filled_count}/${order.count}`);
+                if (order.avg_fill_price) {
+                    this.log(`${chalk.cyan('Avg Fill Price:')} ${order.avg_fill_price.toFixed(2)}`);
+                }
+                this.log();
+                if (order.status === 'executed') {
+                    this.log(chalk.green('✓ Order fully executed'));
+                }
+                else if (order.status === 'resting') {
+                    this.log(chalk.yellow('⏳ Order resting on the book'));
+                }
+            }
+            logger.info({
+                orderId: order.order_id,
+                status: order.status,
+                ticker: flags.ticker,
+            }, 'Order created successfully');
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    formatStatus(status) {
+        const colors = {
+            executed: chalk.green,
+            pending: chalk.yellow,
+            resting: chalk.cyan,
+            canceled: chalk.gray,
+            expired: chalk.red,
+        };
+        const colorFn = colors[status] || chalk.white;
+        return colorFn(status);
+    }
+    async confirm(message) {
+        const readline = await import('node:readline/promises');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const answer = await rl.question(`${message} (y/N): `);
+        rl.close();
+        return answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
+    }
+}

package/dist/commands/orders/list.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../lib/base-command.js';
+export default class OrdersList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        status: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        ticker: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private formatStatus;
+}

package/dist/commands/orders/list.js

@@ -0,0 +1,92 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { BaseCommand } from '../../lib/base-command.js';
+import { createClientFromConfig } from '../../lib/kalshi/index.js';
+import { logger } from '../../lib/logger.js';
+export default class OrdersList extends BaseCommand {
+    static description = 'List orders';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --status resting',
+        '<%= config.bin %> <%= command.id %> --ticker TICKER',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        status: Flags.string({
+            description: 'Filter by order status',
+            options: ['pending', 'resting', 'canceled', 'executed', 'expired'],
+        }),
+        ticker: Flags.string({
+            description: 'Filter by ticker',
+        }),
+        limit: Flags.integer({
+            description: 'Maximum number of orders to return',
+            default: 50,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(OrdersList);
+        try {
+            // Create API client
+            const client = createClientFromConfig();
+            // Fetch orders
+            const result = await client.getOrders({
+                status: flags.status,
+                ticker: flags.ticker,
+                limit: flags.limit,
+            });
+            const orders = result.orders;
+            if (this.formatter.isJSONMode()) {
+                this.formatter.success({ orders, cursor: result.cursor });
+            }
+            else {
+                if (orders.length === 0) {
+                    this.log(chalk.yellow('No orders found'));
+                    return;
+                }
+                this.log(chalk.cyan.bold(`Orders (${orders.length})`));
+                this.log();
+                const rows = orders.map((order) => [
+                    order.order_id.slice(0, 8) + '...',
+                    order.ticker,
+                    this.formatStatus(order.status),
+                    `${order.action.toUpperCase()} ${order.side.toUpperCase()}`,
+                    `${order.filled_count}/${order.count}`,
+                    order.yes_price?.toFixed(2) || order.no_price?.toFixed(2) || 'MKT',
+                    new Date(order.created_time).toLocaleString(),
+                ]);
+                this.formatter.outputTable(['Order ID', 'Ticker', 'Status', 'Action', 'Filled', 'Price', 'Created'], rows);
+                if (result.cursor) {
+                    this.log();
+                    this.log(chalk.gray(`More results available. Use cursor: ${result.cursor}`));
+                }
+                // Summary statistics
+                const statusCounts = orders.reduce((acc, order) => {
+                    acc[order.status] = (acc[order.status] || 0) + 1;
+                    return acc;
+                }, {});
+                this.log();
+                this.log(chalk.cyan('Summary:'));
+                for (const [status, count] of Object.entries(statusCounts)) {
+                    this.log(`  ${this.formatStatus(status)}: ${count}`);
+                }
+            }
+            logger.info({ count: orders.length }, 'Orders fetched successfully');
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    formatStatus(status) {
+        const colors = {
+            executed: chalk.green,
+            pending: chalk.yellow,
+            resting: chalk.cyan,
+            canceled: chalk.gray,
+            expired: chalk.red,
+        };
+        const colorFn = colors[status] || chalk.white;
+        return colorFn(status);
+    }
+}

package/dist/commands/portfolio/balance.d.ts

@@ -0,0 +1,9 @@
+import { BaseCommand } from '../../lib/base-command.js';
+export default class PortfolioBalance extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/portfolio/balance.js

@@ -0,0 +1,36 @@
+import chalk from 'chalk';
+import { BaseCommand } from '../../lib/base-command.js';
+import { createClientFromConfig } from '../../lib/kalshi/index.js';
+import { logger } from '../../lib/logger.js';
+export default class PortfolioBalance extends BaseCommand {
+    static description = 'View account balance';
+    static examples = ['<%= config.bin %> <%= command.id %>', '<%= config.bin %> <%= command.id %> --json'];
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    async run() {
+        await this.parse(PortfolioBalance);
+        try {
+            // Create API client from configuration
+            const client = createClientFromConfig();
+            // Fetch balance
+            const balance = await client.getBalance();
+            if (this.formatter.isJSONMode()) {
+                this.formatter.success(balance);
+            }
+            else {
+                this.log(chalk.cyan.bold('Account Balance'));
+                this.log();
+                this.log(`${chalk.cyan('Balance:')} ${chalk.green('$' + balance.balance.toFixed(2))}`);
+                this.log(`${chalk.cyan('Payout:')} ${chalk.yellow('$' + balance.payout.toFixed(2))}`);
+                this.log();
+                this.log(chalk.gray(`Total: $${(balance.balance + balance.payout).toFixed(2)}`));
+            }
+            logger.info({ balance: balance.balance, payout: balance.payout }, 'Balance fetched successfully');
+        }
+        catch (error) {
+            // Error will be handled by BaseCommand.catch()
+            throw error;
+        }
+    }
+}

package/dist/commands/portfolio/fills.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../lib/base-command.js';
+export default class PortfolioFills extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        ticker: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/portfolio/fills.js

@@ -0,0 +1,80 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { BaseCommand } from '../../lib/base-command.js';
+import { createClientFromConfig } from '../../lib/kalshi/index.js';
+import { logger } from '../../lib/logger.js';
+export default class PortfolioFills extends BaseCommand {
+    static description = 'View trade history (fills)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --ticker TICKER',
+        '<%= config.bin %> <%= command.id %> --limit 20',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        ticker: Flags.string({
+            description: 'Filter by ticker',
+        }),
+        limit: Flags.integer({
+            description: 'Maximum number of fills to return',
+            default: 50,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(PortfolioFills);
+        try {
+            // Create API client
+            const client = createClientFromConfig();
+            // Fetch fills
+            const result = await client.getFills({
+                ticker: flags.ticker,
+                limit: flags.limit,
+            });
+            const fills = result.fills;
+            if (this.formatter.isJSONMode()) {
+                this.formatter.success({ fills, cursor: result.cursor });
+            }
+            else {
+                if (fills.length === 0) {
+                    this.log(chalk.yellow('No fills found'));
+                    return;
+                }
+                this.log(chalk.cyan.bold(`Trade History (${fills.length} fills)`));
+                this.log();
+                const rows = fills.map((fill) => [
+                    fill.ticker,
+                    `${fill.action.toUpperCase()} ${fill.side.toUpperCase()}`,
+                    fill.count.toString(),
+                    fill.price.toFixed(2),
+                    (fill.count * fill.price).toFixed(2),
+                    fill.is_taker ? chalk.yellow('Taker') : chalk.green('Maker'),
+                    new Date(fill.created_time).toLocaleString(),
+                ]);
+                this.formatter.outputTable(['Ticker', 'Action', 'Qty', 'Price', 'Total', 'Type', 'Time'], rows);
+                if (result.cursor) {
+                    this.log();
+                    this.log(chalk.gray(`More results available. Use cursor: ${result.cursor}`));
+                }
+                // Summary statistics
+                const totalVolume = fills.reduce((sum, fill) => sum + fill.count * fill.price, 0);
+                const buyVolume = fills
+                    .filter((f) => f.action === 'buy')
+                    .reduce((sum, fill) => sum + fill.count * fill.price, 0);
+                const sellVolume = fills
+                    .filter((f) => f.action === 'sell')
+                    .reduce((sum, fill) => sum + fill.count * fill.price, 0);
+                this.log();
+                this.log(chalk.cyan('Summary:'));
+                this.log(`  Total Volume: ${chalk.yellow('$' + totalVolume.toFixed(2))}`);
+                this.log(`  Buy Volume: ${chalk.green('$' + buyVolume.toFixed(2))}`);
+                this.log(`  Sell Volume: ${chalk.red('$' + sellVolume.toFixed(2))}`);
+                this.log(`  Net: ${chalk.yellow('$' + (sellVolume - buyVolume).toFixed(2))}`);
+            }
+            logger.info({ count: fills.length }, 'Fills fetched successfully');
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}

package/dist/commands/portfolio/positions.d.ts

@@ -0,0 +1,9 @@
+import { BaseCommand } from '../../lib/base-command.js';
+export default class PortfolioPositions extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/portfolio/positions.js

@@ -0,0 +1,58 @@
+import chalk from 'chalk';
+import { BaseCommand } from '../../lib/base-command.js';
+import { createClientFromConfig } from '../../lib/kalshi/index.js';
+import { logger } from '../../lib/logger.js';
+export default class PortfolioPositions extends BaseCommand {
+    static description = 'View current positions with P&L';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    async run() {
+        await this.parse(PortfolioPositions);
+        try {
+            // Create API client from configuration
+            const client = createClientFromConfig();
+            // Fetch positions
+            const positions = await client.getPositions();
+            if (this.formatter.isJSONMode()) {
+                this.formatter.success(positions);
+            }
+            else {
+                if (positions.length === 0) {
+                    this.log(chalk.yellow('No open positions'));
+                    return;
+                }
+                this.log(chalk.cyan.bold('Current Positions'));
+                this.log();
+                const rows = positions.map((pos) => [
+                    pos.ticker,
+                    pos.position.toString(),
+                    `$${pos.total_cost.toFixed(2)}`,
+                    `$${pos.market_exposure.toFixed(2)}`,
+                    pos.realized_pnl >= 0
+                        ? chalk.green(`+$${pos.realized_pnl.toFixed(2)}`)
+                        : chalk.red(`-$${Math.abs(pos.realized_pnl).toFixed(2)}`),
+                ]);
+                this.formatter.outputTable(['Ticker', 'Quantity', 'Cost', 'Exposure', 'P&L'], rows);
+                const totalCost = positions.reduce((sum, pos) => sum + pos.total_cost, 0);
+                const totalExposure = positions.reduce((sum, pos) => sum + pos.market_exposure, 0);
+                const totalPnL = positions.reduce((sum, pos) => sum + pos.realized_pnl, 0);
+                this.log();
+                this.log(chalk.cyan('Summary:'));
+                this.log(`  Total Cost: ${chalk.yellow('$' + totalCost.toFixed(2))}`);
+                this.log(`  Total Exposure: ${chalk.yellow('$' + totalExposure.toFixed(2))}`);
+                this.log(`  Total P&L: ${totalPnL >= 0
+                    ? chalk.green('+$' + totalPnL.toFixed(2))
+                    : chalk.red('-$' + Math.abs(totalPnL).toFixed(2))}`);
+            }
+            logger.info({ count: positions.length }, 'Positions fetched successfully');
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/lib/base-command.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+import { OutputFormatter } from './output/formatter.js';
+/**
+ * Base command class that all kalshitools commands extend
+ */
+export declare abstract class BaseCommand extends Command {
+    protected formatter: OutputFormatter;
+    static baseFlags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    init(): Promise<void>;
+    protected catch(error: Error): Promise<unknown>;
+}

package/dist/lib/base-command.js

@@ -0,0 +1,38 @@
+import { Command, Flags } from '@oclif/core';
+import { KalshiToolsError } from './errors/base.js';
+import { logger } from './logger.js';
+import { OutputFormatter } from './output/formatter.js';
+/**
+ * Base command class that all kalshitools commands extend
+ */
+export class BaseCommand extends Command {
+    formatter;
+    static baseFlags = {
+        json: Flags.boolean({
+            description: 'Output in JSON format',
+            default: false,
+        }),
+    };
+    async init() {
+        await super.init();
+        const { flags } = await this.parse(this.constructor);
+        this.formatter = new OutputFormatter(flags.json, this.id);
+    }
+    async catch(error) {
+        logger.error({ error, command: this.id }, 'Command failed');
+        if (error instanceof KalshiToolsError) {
+            if (this.formatter?.isJSONMode()) {
+                this.formatter.error(error.code, error.message, error.details);
+            }
+            else {
+                this.error(error.message, { exit: error.exitCode });
+            }
+            this.exit(error.exitCode);
+        }
+        // Handle unexpected errors
+        if (this.formatter?.isJSONMode()) {
+            this.formatter.error('GENERAL_ERROR', error.message);
+        }
+        throw error;
+    }
+}

package/dist/lib/config/manager.d.ts

@@ -0,0 +1,71 @@
+import { type Config, type ApiEnvConfig } from './schema.js';
+/**
+ * Configuration manager for kalshitools
+ */
+export declare class ConfigManager {
+    private store;
+    private static instance;
+    constructor();
+    /**
+     * Get singleton instance
+     */
+    static getInstance(): ConfigManager;
+    /**
+     * Get the full configuration
+     */
+    getConfig(): Config;
+    /**
+     * Get the current environment (demo or production)
+     */
+    getEnvironment(): 'demo' | 'production';
+    /**
+     * Set the environment
+     */
+    setEnvironment(env: 'demo' | 'production'): void;
+    /**
+     * Get API configuration for the current environment
+     */
+    getApiConfig(): ApiEnvConfig;
+    /**
+     * Read private key from file
+     */
+    readPrivateKey(): string;
+    /**
+     * Set API configuration for an environment
+     */
+    setApiConfig(env: 'demo' | 'production', config: Partial<ApiEnvConfig>): void;
+    /**
+     * Get output configuration
+     */
+    getOutputConfig(): {
+        defaultFormat: "json" | "table";
+        colors: boolean;
+    };
+    /**
+     * Get trading configuration
+     */
+    getTradingConfig(): {
+        confirmations: boolean;
+        maxOrderSize: number;
+    };
+    /**
+     * Set a configuration value
+     */
+    set<K extends keyof Config>(key: K, value: Config[K]): void;
+    /**
+     * Get the configuration file path
+     */
+    getConfigPath(): string;
+    /**
+     * Reset configuration to defaults
+     */
+    reset(): void;
+    /**
+     * Check if configuration is initialized
+     */
+    isConfigured(): boolean;
+}
+/**
+ * Get the global configuration manager instance
+ */
+export declare function getConfig(): ConfigManager;