import { z } from '@walkeros/core/dev';

/**
 * CLI Primitive Schemas
 *
 * Basic Zod schemas for CLI parameter validation.
 * Follows walkerOS patterns from @walkeros/core.
 */

/**
 * Port number schema.
 *
 * @remarks
 * Validates HTTP server port number.
 * Must be integer between 1-65535.
 */
declare const PortSchema: z.ZodNumber;
/**
 * File path schema.
 *
 * @remarks
 * Basic string validation for file paths.
 * File existence is checked separately (Zod can't check filesystem).
 */
declare const FilePathSchema: z.ZodString;

/**
 * Run Command Schemas
 *
 * Zod schemas for run command options validation.
 */

/**
 * Run command options schema.
 *
 * @remarks
 * Validates all options for the `walkeros run` command.
 */
declare const RunOptionsSchema: z.ZodObject<{
    flow: z.ZodString;
    port: z.ZodDefault<z.ZodNumber>;
    flowName: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type RunOptions = z.infer<typeof RunOptionsSchema>;

/**
 * Validate Command Schemas
 *
 * Zod schemas for validate command parameter validation.
 */

/**
 * Validation type schema.
 *
 * @remarks
 * Validates the type of validation to perform.
 * - `contract`: Validate a data contract
 * - `event`: Validate a walkerOS event object
 * - `flow`: Validate a flow configuration file
 * - `mapping`: Validate mapping rules
 */
declare const ValidationTypeSchema: z.ZodEnum<{
    flow: "flow";
    contract: "contract";
    event: "event";
    mapping: "mapping";
}>;
type ValidationType = z.infer<typeof ValidationTypeSchema>;
/**
 * Validate options schema.
 *
 * @remarks
 * Options for the programmatic validate() API.
 */
declare const ValidateOptionsSchema: z.ZodObject<{
    flow: z.ZodOptional<z.ZodString>;
    path: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type ValidateOptions = z.infer<typeof ValidateOptionsSchema>;
/**
 * Raw shape for MCP SDK compatibility (ZodRawShapeCompat).
 *
 * @remarks
 * MCP SDK's registerTool expects raw shapes (Record<string, ZodType>)
 * rather than ZodObject instances. Define shape first, then wrap.
 */
declare const ValidateInputShape: {
    type: z.ZodEnum<{
        flow: "flow";
        contract: "contract";
        event: "event";
        mapping: "mapping";
    }>;
    input: z.ZodString;
    flow: z.ZodOptional<z.ZodString>;
    path: z.ZodOptional<z.ZodString>;
};
/**
 * Validate input schema for MCP tools.
 *
 * @remarks
 * Full input schema including type and input source.
 */
declare const ValidateInputSchema: z.ZodObject<{
    type: z.ZodEnum<{
        flow: "flow";
        contract: "contract";
        event: "event";
        mapping: "mapping";
    }>;
    input: z.ZodString;
    flow: z.ZodOptional<z.ZodString>;
    path: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type ValidateInput = z.infer<typeof ValidateInputSchema>;

/**
 * Bundle Command Schemas
 *
 * Zod schemas for bundle command parameter validation.
 */

/**
 * Bundle options schema.
 *
 * @remarks
 * Options for the programmatic bundle() API.
 */
declare const BundleOptionsSchema: z.ZodObject<{
    silent: z.ZodOptional<z.ZodBoolean>;
    verbose: z.ZodOptional<z.ZodBoolean>;
    stats: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    cache: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    flowName: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type BundleOptions = z.infer<typeof BundleOptionsSchema>;
/**
 * Raw shape for MCP SDK compatibility (ZodRawShapeCompat).
 *
 * @remarks
 * MCP SDK's registerTool expects raw shapes (Record<string, ZodType>)
 * rather than ZodObject instances. Define shape first, then wrap.
 */
declare const BundleInputShape: {
    configPath: z.ZodString;
    flow: z.ZodOptional<z.ZodString>;
    stats: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    output: z.ZodOptional<z.ZodString>;
};
/**
 * Bundle input schema for MCP tools.
 *
 * @remarks
 * Full input schema including config path and options.
 */
declare const BundleInputSchema: z.ZodObject<{
    configPath: z.ZodString;
    flow: z.ZodOptional<z.ZodString>;
    stats: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    output: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type BundleInput = z.infer<typeof BundleInputSchema>;

/**
 * Simulate Command Schemas
 *
 * Zod schemas for simulate command parameter validation.
 */

/**
 * Platform schema.
 *
 * @remarks
 * Validates platform type for event simulation.
 */
declare const PlatformSchema: z.ZodEnum<{
    web: "web";
    server: "server";
}>;
type Platform = z.infer<typeof PlatformSchema>;
/**
 * Simulate options schema.
 *
 * @remarks
 * Options for the programmatic simulate() API.
 */
declare const SimulateOptionsSchema: z.ZodObject<{
    silent: z.ZodOptional<z.ZodBoolean>;
    verbose: z.ZodOptional<z.ZodBoolean>;
    json: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;
type SimulateOptions = z.infer<typeof SimulateOptionsSchema>;
/**
 * Raw shape for MCP SDK compatibility (ZodRawShapeCompat).
 *
 * @remarks
 * MCP SDK's registerTool expects raw shapes (Record<string, ZodType>)
 * rather than ZodObject instances. Define shape first, then wrap.
 */
declare const SimulateInputShape: {
    configPath: z.ZodString;
    event: z.ZodOptional<z.ZodString>;
    flow: z.ZodOptional<z.ZodString>;
    platform: z.ZodOptional<z.ZodEnum<{
        web: "web";
        server: "server";
    }>>;
    step: z.ZodOptional<z.ZodString>;
};
/**
 * Simulate input schema for MCP tools.
 *
 * @remarks
 * Full input schema including config path, event, and options.
 */
declare const SimulateInputSchema: z.ZodObject<{
    configPath: z.ZodString;
    event: z.ZodOptional<z.ZodString>;
    flow: z.ZodOptional<z.ZodString>;
    platform: z.ZodOptional<z.ZodEnum<{
        web: "web";
        server: "server";
    }>>;
    step: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type SimulateInput = z.infer<typeof SimulateInputSchema>;

/**
 * Push Command Schemas
 *
 * Zod schemas for push command parameter validation.
 */

/**
 * Push options schema.
 *
 * @remarks
 * Options for the programmatic push() API.
 */
declare const PushOptionsSchema: z.ZodObject<{
    silent: z.ZodOptional<z.ZodBoolean>;
    verbose: z.ZodOptional<z.ZodBoolean>;
    json: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;
type PushOptions = z.infer<typeof PushOptionsSchema>;
/**
 * Raw shape for MCP SDK compatibility (ZodRawShapeCompat).
 *
 * @remarks
 * MCP SDK's registerTool expects raw shapes (Record<string, ZodType>)
 * rather than ZodObject instances. Define shape first, then wrap.
 */
declare const PushInputShape: {
    configPath: z.ZodString;
    event: z.ZodString;
    flow: z.ZodOptional<z.ZodString>;
    platform: z.ZodOptional<z.ZodEnum<{
        web: "web";
        server: "server";
    }>>;
};
/**
 * Push input schema for MCP tools.
 *
 * @remarks
 * Full input schema including config path, event, and options.
 */
declare const PushInputSchema: z.ZodObject<{
    configPath: z.ZodString;
    event: z.ZodString;
    flow: z.ZodOptional<z.ZodString>;
    platform: z.ZodOptional<z.ZodEnum<{
        web: "web";
        server: "server";
    }>>;
}, z.core.$strip>;
type PushInput = z.infer<typeof PushInputSchema>;

/**
 * CLI Schemas
 *
 * Zod schemas for CLI parameter validation.
 * Follows walkerOS patterns from @walkeros/core.
 */

type index_BundleInput = BundleInput;
declare const index_BundleInputSchema: typeof BundleInputSchema;
declare const index_BundleInputShape: typeof BundleInputShape;
type index_BundleOptions = BundleOptions;
declare const index_BundleOptionsSchema: typeof BundleOptionsSchema;
declare const index_FilePathSchema: typeof FilePathSchema;
type index_Platform = Platform;
declare const index_PlatformSchema: typeof PlatformSchema;
declare const index_PortSchema: typeof PortSchema;
type index_PushInput = PushInput;
declare const index_PushInputSchema: typeof PushInputSchema;
declare const index_PushInputShape: typeof PushInputShape;
type index_PushOptions = PushOptions;
declare const index_PushOptionsSchema: typeof PushOptionsSchema;
type index_RunOptions = RunOptions;
declare const index_RunOptionsSchema: typeof RunOptionsSchema;
type index_SimulateInput = SimulateInput;
declare const index_SimulateInputSchema: typeof SimulateInputSchema;
declare const index_SimulateInputShape: typeof SimulateInputShape;
type index_SimulateOptions = SimulateOptions;
declare const index_SimulateOptionsSchema: typeof SimulateOptionsSchema;
type index_ValidateInput = ValidateInput;
declare const index_ValidateInputSchema: typeof ValidateInputSchema;
declare const index_ValidateInputShape: typeof ValidateInputShape;
type index_ValidateOptions = ValidateOptions;
declare const index_ValidateOptionsSchema: typeof ValidateOptionsSchema;
type index_ValidationType = ValidationType;
declare const index_ValidationTypeSchema: typeof ValidationTypeSchema;
declare namespace index {
  export { type index_BundleInput as BundleInput, index_BundleInputSchema as BundleInputSchema, index_BundleInputShape as BundleInputShape, type index_BundleOptions as BundleOptions, index_BundleOptionsSchema as BundleOptionsSchema, index_FilePathSchema as FilePathSchema, type index_Platform as Platform, index_PlatformSchema as PlatformSchema, index_PortSchema as PortSchema, type index_PushInput as PushInput, index_PushInputSchema as PushInputSchema, index_PushInputShape as PushInputShape, type index_PushOptions as PushOptions, index_PushOptionsSchema as PushOptionsSchema, type index_RunOptions as RunOptions, index_RunOptionsSchema as RunOptionsSchema, type index_SimulateInput as SimulateInput, index_SimulateInputSchema as SimulateInputSchema, index_SimulateInputShape as SimulateInputShape, type index_SimulateOptions as SimulateOptions, index_SimulateOptionsSchema as SimulateOptionsSchema, type index_ValidateInput as ValidateInput, index_ValidateInputSchema as ValidateInputSchema, index_ValidateInputShape as ValidateInputShape, type index_ValidateOptions as ValidateOptions, index_ValidateOptionsSchema as ValidateOptionsSchema, type index_ValidationType as ValidationType, index_ValidationTypeSchema as ValidationTypeSchema };
}

export { index as schemas };