@necto-ai/pgit/dist/types/config.schema.d.ts

Private file tracking with dual git repositories

import { z } from 'zod';
/**
 * Zod schema for git exclude settings
 */
export declare const GitExcludeSettingsSchema: z.ZodObject<{
    enabled: z.ZodBoolean;
    markerComment: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
    fallbackBehavior: z.ZodEnum<["warn", "silent", "error"]>;
    validateOperations: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    enabled: boolean;
    markerComment: string;
    fallbackBehavior: "warn" | "silent" | "error";
    validateOperations: boolean;
}, {
    enabled: boolean;
    markerComment: string;
    fallbackBehavior: "warn" | "silent" | "error";
    validateOperations: boolean;
}>;
/**
 * Zod schema for configuration settings
 */
export declare const ConfigSettingsSchema: z.ZodObject<{
    autoGitignore: z.ZodBoolean;
    autoCleanup: z.ZodBoolean;
    verboseOutput: z.ZodBoolean;
    createBackups: z.ZodBoolean;
    maxBackups: z.ZodNumber;
    gitExclude: z.ZodObject<{
        enabled: z.ZodBoolean;
        markerComment: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
        fallbackBehavior: z.ZodEnum<["warn", "silent", "error"]>;
        validateOperations: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        enabled: boolean;
        markerComment: string;
        fallbackBehavior: "warn" | "silent" | "error";
        validateOperations: boolean;
    }, {
        enabled: boolean;
        markerComment: string;
        fallbackBehavior: "warn" | "silent" | "error";
        validateOperations: boolean;
    }>;
}, "strip", z.ZodTypeAny, {
    autoGitignore: boolean;
    autoCleanup: boolean;
    verboseOutput: boolean;
    createBackups: boolean;
    maxBackups: number;
    gitExclude: {
        enabled: boolean;
        markerComment: string;
        fallbackBehavior: "warn" | "silent" | "error";
        validateOperations: boolean;
    };
}, {
    autoGitignore: boolean;
    autoCleanup: boolean;
    verboseOutput: boolean;
    createBackups: boolean;
    maxBackups: number;
    gitExclude: {
        enabled: boolean;
        markerComment: string;
        fallbackBehavior: "warn" | "silent" | "error";
        validateOperations: boolean;
    };
}>;
/**
 * Zod schema for preset configuration
 */
export declare const PresetSchema: z.ZodObject<{
    description: z.ZodString;
    category: z.ZodOptional<z.ZodString>;
    paths: z.ZodArray<z.ZodString, "many">;
    created: z.ZodOptional<z.ZodDate>;
    lastUsed: z.ZodOptional<z.ZodDate>;
}, "strip", z.ZodTypeAny, {
    description: string;
    paths: string[];
    category?: string | undefined;
    created?: Date | undefined;
    lastUsed?: Date | undefined;
}, {
    description: string;
    paths: string[];
    category?: string | undefined;
    created?: Date | undefined;
    lastUsed?: Date | undefined;
}>;
/**
 * Zod schema for built-in presets file
 */
export declare const BuiltinPresetsSchema: z.ZodObject<{
    version: z.ZodString;
    presets: z.ZodRecord<z.ZodString, z.ZodObject<{
        description: z.ZodString;
        category: z.ZodOptional<z.ZodString>;
        paths: z.ZodArray<z.ZodString, "many">;
        created: z.ZodOptional<z.ZodDate>;
        lastUsed: z.ZodOptional<z.ZodDate>;
    }, "strip", z.ZodTypeAny, {
        description: string;
        paths: string[];
        category?: string | undefined;
        created?: Date | undefined;
        lastUsed?: Date | undefined;
    }, {
        description: string;
        paths: string[];
        category?: string | undefined;
        created?: Date | undefined;
        lastUsed?: Date | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    version: string;
    presets: Record<string, {
        description: string;
        paths: string[];
        category?: string | undefined;
        created?: Date | undefined;
        lastUsed?: Date | undefined;
    }>;
}, {
    version: string;
    presets: Record<string, {
        description: string;
        paths: string[];
        category?: string | undefined;
        created?: Date | undefined;
        lastUsed?: Date | undefined;
    }>;
}>;
/**
 * Zod schema for project metadata
 */
export declare const ProjectMetadataSchema: z.ZodObject<{
    projectName: z.ZodString;
    mainRepoPath: z.ZodString;
    cliVersion: z.ZodString;
    platform: z.ZodString;
    lastModified: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    projectName: string;
    mainRepoPath: string;
    cliVersion: string;
    platform: string;
    lastModified: Date;
}, {
    projectName: string;
    mainRepoPath: string;
    cliVersion: string;
    platform: string;
    lastModified: Date;
}>;
/**
 * Zod schema for main private configuration
 */
export declare const PrivateConfigSchema: z.ZodObject<{
    version: z.ZodString;
    privateRepoPath: z.ZodString;
    storagePath: z.ZodString;
    trackedPaths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    initialized: z.ZodDate;
    lastCleanup: z.ZodOptional<z.ZodDate>;
    settings: z.ZodObject<{
        autoGitignore: z.ZodBoolean;
        autoCleanup: z.ZodBoolean;
        verboseOutput: z.ZodBoolean;
        createBackups: z.ZodBoolean;
        maxBackups: z.ZodNumber;
        gitExclude: z.ZodObject<{
            enabled: z.ZodBoolean;
            markerComment: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
            fallbackBehavior: z.ZodEnum<["warn", "silent", "error"]>;
            validateOperations: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            enabled: boolean;
            markerComment: string;
            fallbackBehavior: "warn" | "silent" | "error";
            validateOperations: boolean;
        }, {
            enabled: boolean;
            markerComment: string;
            fallbackBehavior: "warn" | "silent" | "error";
            validateOperations: boolean;
        }>;
    }, "strip", z.ZodTypeAny, {
        autoGitignore: boolean;
        autoCleanup: boolean;
        verboseOutput: boolean;
        createBackups: boolean;
        maxBackups: number;
        gitExclude: {
            enabled: boolean;
            markerComment: string;
            fallbackBehavior: "warn" | "silent" | "error";
            validateOperations: boolean;
        };
    }, {
        autoGitignore: boolean;
        autoCleanup: boolean;
        verboseOutput: boolean;
        createBackups: boolean;
        maxBackups: number;
        gitExclude: {
            enabled: boolean;
            markerComment: string;
            fallbackBehavior: "warn" | "silent" | "error";
            validateOperations: boolean;
        };
    }>;
    metadata: z.ZodObject<{
        projectName: z.ZodString;
        mainRepoPath: z.ZodString;
        cliVersion: z.ZodString;
        platform: z.ZodString;
        lastModified: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        projectName: string;
        mainRepoPath: string;
        cliVersion: string;
        platform: string;
        lastModified: Date;
    }, {
        projectName: string;
        mainRepoPath: string;
        cliVersion: string;
        platform: string;
        lastModified: Date;
    }>;
    presets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        description: z.ZodString;
        category: z.ZodOptional<z.ZodString>;
        paths: z.ZodArray<z.ZodString, "many">;
        created: z.ZodOptional<z.ZodDate>;
        lastUsed: z.ZodOptional<z.ZodDate>;
    }, "strip", z.ZodTypeAny, {
        description: string;
        paths: string[];
        category?: string | undefined;
        created?: Date | undefined;
        lastUsed?: Date | undefined;
    }, {
        description: string;
        paths: string[];
        category?: string | undefined;
        created?: Date | undefined;
        lastUsed?: Date | undefined;
    }>>>;
}, "strip", z.ZodTypeAny, {
    version: string;
    privateRepoPath: string;
    storagePath: string;
    trackedPaths: string[];
    initialized: Date;
    settings: {
        autoGitignore: boolean;
        autoCleanup: boolean;
        verboseOutput: boolean;
        createBackups: boolean;
        maxBackups: number;
        gitExclude: {
            enabled: boolean;
            markerComment: string;
            fallbackBehavior: "warn" | "silent" | "error";
            validateOperations: boolean;
        };
    };
    metadata: {
        projectName: string;
        mainRepoPath: string;
        cliVersion: string;
        platform: string;
        lastModified: Date;
    };
    presets?: Record<string, {
        description: string;
        paths: string[];
        category?: string | undefined;
        created?: Date | undefined;
        lastUsed?: Date | undefined;
    }> | undefined;
    lastCleanup?: Date | undefined;
}, {
    version: string;
    privateRepoPath: string;
    storagePath: string;
    initialized: Date;
    settings: {
        autoGitignore: boolean;
        autoCleanup: boolean;
        verboseOutput: boolean;
        createBackups: boolean;
        maxBackups: number;
        gitExclude: {
            enabled: boolean;
            markerComment: string;
            fallbackBehavior: "warn" | "silent" | "error";
            validateOperations: boolean;
        };
    };
    metadata: {
        projectName: string;
        mainRepoPath: string;
        cliVersion: string;
        platform: string;
        lastModified: Date;
    };
    presets?: Record<string, {
        description: string;
        paths: string[];
        category?: string | undefined;
        created?: Date | undefined;
        lastUsed?: Date | undefined;
    }> | undefined;
    trackedPaths?: string[] | undefined;
    lastCleanup?: Date | undefined;
}>;
/**
 * Zod schema for command result
 */
export declare const CommandResultSchema: z.ZodObject<{
    success: z.ZodBoolean;
    message: z.ZodOptional<z.ZodString>;
    data: z.ZodOptional<z.ZodUnknown>;
    error: z.ZodOptional<z.ZodType<Error, z.ZodTypeDef, Error>>;
    exitCode: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    success: boolean;
    exitCode: number;
    error?: Error | undefined;
    message?: string | undefined;
    data?: unknown;
}, {
    success: boolean;
    exitCode: number;
    error?: Error | undefined;
    message?: string | undefined;
    data?: unknown;
}>;
/**
 * Zod schema for command options
 */
export declare const CommandOptionsSchema: z.ZodObject<{
    verbose: z.ZodOptional<z.ZodBoolean>;
    force: z.ZodOptional<z.ZodBoolean>;
    message: z.ZodOptional<z.ZodString>;
    dryRun: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    message?: string | undefined;
    verbose?: boolean | undefined;
    force?: boolean | undefined;
    dryRun?: boolean | undefined;
}, {
    message?: string | undefined;
    verbose?: boolean | undefined;
    force?: boolean | undefined;
    dryRun?: boolean | undefined;
}>;
/**
 * Zod schema for repository status
 */
export declare const RepositoryStatusSchema: z.ZodObject<{
    type: z.ZodEnum<["main", "private"]>;
    branch: z.ZodString;
    isClean: z.ZodBoolean;
    stagedFiles: z.ZodNumber;
    modifiedFiles: z.ZodNumber;
    untrackedFiles: z.ZodNumber;
    deletedFiles: z.ZodNumber;
    exists: z.ZodBoolean;
    issues: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    issues: string[];
    type: "main" | "private";
    branch: string;
    isClean: boolean;
    stagedFiles: number;
    modifiedFiles: number;
    untrackedFiles: number;
    deletedFiles: number;
    exists: boolean;
}, {
    issues: string[];
    type: "main" | "private";
    branch: string;
    isClean: boolean;
    stagedFiles: number;
    modifiedFiles: number;
    untrackedFiles: number;
    deletedFiles: number;
    exists: boolean;
}>;
/**
 * Zod schema for broken link information
 */
export declare const BrokenLinkSchema: z.ZodObject<{
    linkPath: z.ZodString;
    targetPath: z.ZodString;
    reason: z.ZodString;
    repairable: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    linkPath: string;
    targetPath: string;
    reason: string;
    repairable: boolean;
}, {
    linkPath: string;
    targetPath: string;
    reason: string;
    repairable: boolean;
}>;
/**
 * Zod schema for symbolic link health
 */
export declare const SymlinkHealthSchema: z.ZodObject<{
    total: z.ZodNumber;
    healthy: z.ZodNumber;
    broken: z.ZodNumber;
    brokenLinks: z.ZodArray<z.ZodObject<{
        linkPath: z.ZodString;
        targetPath: z.ZodString;
        reason: z.ZodString;
        repairable: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        linkPath: string;
        targetPath: string;
        reason: string;
        repairable: boolean;
    }, {
        linkPath: string;
        targetPath: string;
        reason: string;
        repairable: boolean;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    total: number;
    healthy: number;
    broken: number;
    brokenLinks: {
        linkPath: string;
        targetPath: string;
        reason: string;
        repairable: boolean;
    }[];
}, {
    total: number;
    healthy: number;
    broken: number;
    brokenLinks: {
        linkPath: string;
        targetPath: string;
        reason: string;
        repairable: boolean;
    }[];
}>;
/**
 * Zod schema for configuration health
 */
export declare const ConfigHealthSchema: z.ZodObject<{
    exists: z.ZodBoolean;
    valid: z.ZodBoolean;
    errors: z.ZodArray<z.ZodString, "many">;
    needsMigration: z.ZodBoolean;
    currentVersion: z.ZodString;
    targetVersion: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    valid: boolean;
    exists: boolean;
    errors: string[];
    needsMigration: boolean;
    currentVersion: string;
    targetVersion?: string | undefined;
}, {
    valid: boolean;
    exists: boolean;
    errors: string[];
    needsMigration: boolean;
    currentVersion: string;
    targetVersion?: string | undefined;
}>;
/**
 * Zod schema for system status
 */
export declare const SystemStatusSchema: z.ZodObject<{
    initialized: z.ZodBoolean;
    mainRepo: z.ZodObject<{
        type: z.ZodEnum<["main", "private"]>;
        branch: z.ZodString;
        isClean: z.ZodBoolean;
        stagedFiles: z.ZodNumber;
        modifiedFiles: z.ZodNumber;
        untrackedFiles: z.ZodNumber;
        deletedFiles: z.ZodNumber;
        exists: z.ZodBoolean;
        issues: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        issues: string[];
        type: "main" | "private";
        branch: string;
        isClean: boolean;
        stagedFiles: number;
        modifiedFiles: number;
        untrackedFiles: number;
        deletedFiles: number;
        exists: boolean;
    }, {
        issues: string[];
        type: "main" | "private";
        branch: string;
        isClean: boolean;
        stagedFiles: number;
        modifiedFiles: number;
        untrackedFiles: number;
        deletedFiles: number;
        exists: boolean;
    }>;
    privateRepo: z.ZodObject<{
        type: z.ZodEnum<["main", "private"]>;
        branch: z.ZodString;
        isClean: z.ZodBoolean;
        stagedFiles: z.ZodNumber;
        modifiedFiles: z.ZodNumber;
        untrackedFiles: z.ZodNumber;
        deletedFiles: z.ZodNumber;
        exists: z.ZodBoolean;
        issues: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        issues: string[];
        type: "main" | "private";
        branch: string;
        isClean: boolean;
        stagedFiles: number;
        modifiedFiles: number;
        untrackedFiles: number;
        deletedFiles: number;
        exists: boolean;
    }, {
        issues: string[];
        type: "main" | "private";
        branch: string;
        isClean: boolean;
        stagedFiles: number;
        modifiedFiles: number;
        untrackedFiles: number;
        deletedFiles: number;
        exists: boolean;
    }>;
    symlinks: z.ZodObject<{
        total: z.ZodNumber;
        healthy: z.ZodNumber;
        broken: z.ZodNumber;
        brokenLinks: z.ZodArray<z.ZodObject<{
            linkPath: z.ZodString;
            targetPath: z.ZodString;
            reason: z.ZodString;
            repairable: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            linkPath: string;
            targetPath: string;
            reason: string;
            repairable: boolean;
        }, {
            linkPath: string;
            targetPath: string;
            reason: string;
            repairable: boolean;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        total: number;
        healthy: number;
        broken: number;
        brokenLinks: {
            linkPath: string;
            targetPath: string;
            reason: string;
            repairable: boolean;
        }[];
    }, {
        total: number;
        healthy: number;
        broken: number;
        brokenLinks: {
            linkPath: string;
            targetPath: string;
            reason: string;
            repairable: boolean;
        }[];
    }>;
    config: z.ZodObject<{
        exists: z.ZodBoolean;
        valid: z.ZodBoolean;
        errors: z.ZodArray<z.ZodString, "many">;
        needsMigration: z.ZodBoolean;
        currentVersion: z.ZodString;
        targetVersion: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        valid: boolean;
        exists: boolean;
        errors: string[];
        needsMigration: boolean;
        currentVersion: string;
        targetVersion?: string | undefined;
    }, {
        valid: boolean;
        exists: boolean;
        errors: string[];
        needsMigration: boolean;
        currentVersion: string;
        targetVersion?: string | undefined;
    }>;
    isHealthy: z.ZodBoolean;
    issues: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    issues: string[];
    initialized: boolean;
    mainRepo: {
        issues: string[];
        type: "main" | "private";
        branch: string;
        isClean: boolean;
        stagedFiles: number;
        modifiedFiles: number;
        untrackedFiles: number;
        deletedFiles: number;
        exists: boolean;
    };
    privateRepo: {
        issues: string[];
        type: "main" | "private";
        branch: string;
        isClean: boolean;
        stagedFiles: number;
        modifiedFiles: number;
        untrackedFiles: number;
        deletedFiles: number;
        exists: boolean;
    };
    symlinks: {
        total: number;
        healthy: number;
        broken: number;
        brokenLinks: {
            linkPath: string;
            targetPath: string;
            reason: string;
            repairable: boolean;
        }[];
    };
    config: {
        valid: boolean;
        exists: boolean;
        errors: string[];
        needsMigration: boolean;
        currentVersion: string;
        targetVersion?: string | undefined;
    };
    isHealthy: boolean;
}, {
    issues: string[];
    initialized: boolean;
    mainRepo: {
        issues: string[];
        type: "main" | "private";
        branch: string;
        isClean: boolean;
        stagedFiles: number;
        modifiedFiles: number;
        untrackedFiles: number;
        deletedFiles: number;
        exists: boolean;
    };
    privateRepo: {
        issues: string[];
        type: "main" | "private";
        branch: string;
        isClean: boolean;
        stagedFiles: number;
        modifiedFiles: number;
        untrackedFiles: number;
        deletedFiles: number;
        exists: boolean;
    };
    symlinks: {
        total: number;
        healthy: number;
        broken: number;
        brokenLinks: {
            linkPath: string;
            targetPath: string;
            reason: string;
            repairable: boolean;
        }[];
    };
    config: {
        valid: boolean;
        exists: boolean;
        errors: string[];
        needsMigration: boolean;
        currentVersion: string;
        targetVersion?: string | undefined;
    };
    isHealthy: boolean;
}>;
/**
 * Zod schema for tracked file information
 */
export declare const TrackedFileSchema: z.ZodObject<{
    originalPath: z.ZodString;
    storagePath: z.ZodString;
    isSymlink: z.ZodBoolean;
    symlinkHealthy: z.ZodBoolean;
    addedDate: z.ZodDate;
    size: z.ZodNumber;
    isDirectory: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    storagePath: string;
    originalPath: string;
    isSymlink: boolean;
    symlinkHealthy: boolean;
    addedDate: Date;
    size: number;
    isDirectory: boolean;
}, {
    storagePath: string;
    originalPath: string;
    isSymlink: boolean;
    symlinkHealthy: boolean;
    addedDate: Date;
    size: number;
    isDirectory: boolean;
}>;
/**
 * Zod schema for validation result
 */
export declare const ValidationResultSchema: z.ZodObject<{
    valid: z.ZodBoolean;
    errors: z.ZodArray<z.ZodString, "many">;
    warnings: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    valid: boolean;
    errors: string[];
    warnings: string[];
}, {
    valid: boolean;
    errors: string[];
    warnings: string[];
}>;
/**
 * Zod schema for migration step
 */
export declare const MigrationStepSchema: z.ZodObject<{
    id: z.ZodString;
    description: z.ZodString;
    destructive: z.ZodBoolean;
    execute: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
}, "strip", z.ZodTypeAny, {
    description: string;
    id: string;
    destructive: boolean;
    execute: (...args: unknown[]) => unknown;
}, {
    description: string;
    id: string;
    destructive: boolean;
    execute: (...args: unknown[]) => unknown;
}>;
/**
 * Zod schema for migration information
 */
export declare const MigrationInfoSchema: z.ZodObject<{
    fromVersion: z.ZodString;
    toVersion: z.ZodString;
    steps: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        description: z.ZodString;
        destructive: z.ZodBoolean;
        execute: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
    }, "strip", z.ZodTypeAny, {
        description: string;
        id: string;
        destructive: boolean;
        execute: (...args: unknown[]) => unknown;
    }, {
        description: string;
        id: string;
        destructive: boolean;
        execute: (...args: unknown[]) => unknown;
    }>, "many">;
    required: z.ZodBoolean;
    safe: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    required: boolean;
    fromVersion: string;
    toVersion: string;
    steps: {
        description: string;
        id: string;
        destructive: boolean;
        execute: (...args: unknown[]) => unknown;
    }[];
    safe: boolean;
}, {
    required: boolean;
    fromVersion: string;
    toVersion: string;
    steps: {
        description: string;
        id: string;
        destructive: boolean;
        execute: (...args: unknown[]) => unknown;
    }[];
    safe: boolean;
}>;
/**
 * Zod schema for error information
 */
export declare const ErrorInfoSchema: z.ZodObject<{
    code: z.ZodString;
    message: z.ZodString;
    details: z.ZodOptional<z.ZodString>;
    suggestion: z.ZodOptional<z.ZodString>;
    recoverable: z.ZodBoolean;
    stack: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    code: string;
    message: string;
    recoverable: boolean;
    details?: string | undefined;
    suggestion?: string | undefined;
    stack?: string | undefined;
}, {
    code: string;
    message: string;
    recoverable: boolean;
    details?: string | undefined;
    suggestion?: string | undefined;
    stack?: string | undefined;
}>;
/**
 * Schema for validating file paths
 */
export declare const FilePathSchema: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
/**
 * Schema for validating git commit messages
 */
export declare const CommitMessageSchema: z.ZodEffects<z.ZodString, string, string>;
/**
 * Schema for validating branch names
 */
export declare const BranchNameSchema: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
/**
 * Transform function to convert ISO date strings to Date objects
 */
export declare const dateTransform: z.ZodEffects<z.ZodString, Date, string>;
/**
 * JSON serialization schema for configuration
 */
export declare const PrivateConfigJsonSchema: z.ZodObject<{
    version: z.ZodString;
    privateRepoPath: z.ZodString;
    storagePath: z.ZodString;
    trackedPaths: z.ZodArray<z.ZodString, "many">;
    initialized: z.ZodEffects<z.ZodString, Date, string>;
    lastCleanup: z.ZodOptional<z.ZodEffects<z.ZodString, Date, string>>;
    settings: z.ZodObject<{
        autoGitignore: z.ZodBoolean;
        autoCleanup: z.ZodBoolean;
        verboseOutput: z.ZodBoolean;
        createBackups: z.ZodBoolean;
        maxBackups: z.ZodNumber;
        gitExclude: z.ZodObject<{
            enabled: z.ZodBoolean;
            markerComment: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
            fallbackBehavior: z.ZodEnum<["warn", "silent", "error"]>;
            validateOperations: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            enabled: boolean;
            markerComment: string;
            fallbackBehavior: "warn" | "silent" | "error";
            validateOperations: boolean;
        }, {
            enabled: boolean;
            markerComment: string;
            fallbackBehavior: "warn" | "silent" | "error";
            validateOperations: boolean;
        }>;
    }, "strip", z.ZodTypeAny, {
        autoGitignore: boolean;
        autoCleanup: boolean;
        verboseOutput: boolean;
        createBackups: boolean;
        maxBackups: number;
        gitExclude: {
            enabled: boolean;
            markerComment: string;
            fallbackBehavior: "warn" | "silent" | "error";
            validateOperations: boolean;
        };
    }, {
        autoGitignore: boolean;
        autoCleanup: boolean;
        verboseOutput: boolean;
        createBackups: boolean;
        maxBackups: number;
        gitExclude: {
            enabled: boolean;
            markerComment: string;
            fallbackBehavior: "warn" | "silent" | "error";
            validateOperations: boolean;
        };
    }>;
    metadata: z.ZodObject<{
        projectName: z.ZodString;
        mainRepoPath: z.ZodString;
        cliVersion: z.ZodString;
        platform: z.ZodString;
        lastModified: z.ZodEffects<z.ZodString, Date, string>;
    }, "strip", z.ZodTypeAny, {
        projectName: string;
        mainRepoPath: string;
        cliVersion: string;
        platform: string;
        lastModified: Date;
    }, {
        projectName: string;
        mainRepoPath: string;
        cliVersion: string;
        platform: string;
        lastModified: string;
    }>;
}, "strip", z.ZodTypeAny, {
    version: string;
    privateRepoPath: string;
    storagePath: string;
    trackedPaths: string[];
    initialized: Date;
    settings: {
        autoGitignore: boolean;
        autoCleanup: boolean;
        verboseOutput: boolean;
        createBackups: boolean;
        maxBackups: number;
        gitExclude: {
            enabled: boolean;
            markerComment: string;
            fallbackBehavior: "warn" | "silent" | "error";
            validateOperations: boolean;
        };
    };
    metadata: {
        projectName: string;
        mainRepoPath: string;
        cliVersion: string;
        platform: string;
        lastModified: Date;
    };
    lastCleanup?: Date | undefined;
}, {
    version: string;
    privateRepoPath: string;
    storagePath: string;
    trackedPaths: string[];
    initialized: string;
    settings: {
        autoGitignore: boolean;
        autoCleanup: boolean;
        verboseOutput: boolean;
        createBackups: boolean;
        maxBackups: number;
        gitExclude: {
            enabled: boolean;
            markerComment: string;
            fallbackBehavior: "warn" | "silent" | "error";
            validateOperations: boolean;
        };
    };
    metadata: {
        projectName: string;
        mainRepoPath: string;
        cliVersion: string;
        platform: string;
        lastModified: string;
    };
    lastCleanup?: string | undefined;
}>;
/**
 * Type definitions inferred from schemas
 */
export type ConfigSettingsType = z.infer<typeof ConfigSettingsSchema>;
export type ProjectMetadataType = z.infer<typeof ProjectMetadataSchema>;
export type PrivateConfigType = z.infer<typeof PrivateConfigSchema>;
export type CommandResultType = z.infer<typeof CommandResultSchema>;
export type CommandOptionsType = z.infer<typeof CommandOptionsSchema>;
export type RepositoryStatusType = z.infer<typeof RepositoryStatusSchema>;
export type BrokenLinkType = z.infer<typeof BrokenLinkSchema>;
export type SymlinkHealthType = z.infer<typeof SymlinkHealthSchema>;
export type ConfigHealthType = z.infer<typeof ConfigHealthSchema>;
export type SystemStatusType = z.infer<typeof SystemStatusSchema>;
export type TrackedFileType = z.infer<typeof TrackedFileSchema>;
export type ValidationResultType = z.infer<typeof ValidationResultSchema>;
export type MigrationStepType = z.infer<typeof MigrationStepSchema>;
export type MigrationInfoType = z.infer<typeof MigrationInfoSchema>;
export type ErrorInfoType = z.infer<typeof ErrorInfoSchema>;
//# sourceMappingURL=config.schema.d.ts.map