import * as z from 'zod';
import { z as z$1 } from 'zod';
export { z };
import * as hjson$1 from 'hjson';
import hjson__default from 'hjson';
import * as ini$1 from 'ini';
import * as js_yaml from 'js-yaml';
import * as papaparse from 'papaparse';
import { UnparseConfig } from 'papaparse';
import * as fast_xml_parser from 'fast-xml-parser';
import { XmlBuilderOptions } from 'fast-xml-parser';
import * as _dotenvx_dotenvx from '@dotenvx/dotenvx';
import { DotenvConfigOptions } from '@dotenvx/dotenvx';
import * as TOML from '@iarna/toml';

declare const backupTargetOptionsSchema: z.ZodObject<{
    enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
    maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
    onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
        overwrite: "overwrite";
        increment: "increment";
        skip: "skip";
        fail: "fail";
    }>>>;
}, z.core.$strip>;
declare const backupTargetSchema: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
    enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
    maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
    onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
        overwrite: "overwrite";
        increment: "increment";
        skip: "skip";
        fail: "fail";
    }>>>;
}, z.core.$strip>]>>;
declare const jsonTargetSchema: z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"json">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<JsonTargetOptions, JsonTargetOptions>>;
}, z.core.$strip>;
declare const json5TargetSchema: z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"json5">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<Json5TargetOptions, Json5TargetOptions>>;
}, z.core.$strip>;
declare const jsoncTargetSchema: z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"jsonc">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<JsoncTargetOptions, JsoncTargetOptions>>;
}, z.core.$strip>;
declare const hjsonTargetSchema: z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"hjson">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<hjson$1.SerializeOptions, hjson$1.SerializeOptions>>;
}, z.core.$strip>;
declare const yamlTargetSchema: z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"yaml">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<js_yaml.DumpOptions, js_yaml.DumpOptions>>;
}, z.core.$strip>;
declare const tomlTargetSchema: z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"toml">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
}, z.core.$strip>;
declare const iniTargetSchema: z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"ini">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<ini$1.EncodeOptions, ini$1.EncodeOptions>>;
}, z.core.$strip>;
declare const propertiesTargetSchema: z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"properties">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<PropertiesTargetOptions, PropertiesTargetOptions>>;
}, z.core.$strip>;
declare const envTargetSchema: z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"env">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
}, z.core.$strip>;
declare const xmlTargetSchema: z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"xml">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<fast_xml_parser.XmlBuilderOptions, fast_xml_parser.XmlBuilderOptions>>;
}, z.core.$strip>;
declare const csvTargetSchema: z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"csv">;
    variables: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>;
    options: z.ZodOptional<z.ZodCustom<papaparse.UnparseConfig, papaparse.UnparseConfig>>;
}, z.core.$strip>;
declare const csonTargetSchema: z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"cson">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
}, z.core.$strip>;
declare const templateTargetSchema: z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"template">;
    engine: z.ZodDefault<z.ZodEnum<{
        nunjucks: "nunjucks";
        handlebars: "handlebars";
        mustache: "mustache";
    }>>;
    template: z.ZodString;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
}, z.core.$strip>;
declare const anyTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"json">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<JsonTargetOptions, JsonTargetOptions>>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"json5">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<Json5TargetOptions, Json5TargetOptions>>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"jsonc">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<JsoncTargetOptions, JsoncTargetOptions>>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"hjson">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<hjson$1.SerializeOptions, hjson$1.SerializeOptions>>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"yaml">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<js_yaml.DumpOptions, js_yaml.DumpOptions>>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"toml">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"ini">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<ini$1.EncodeOptions, ini$1.EncodeOptions>>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"properties">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<PropertiesTargetOptions, PropertiesTargetOptions>>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"env">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"xml">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<fast_xml_parser.XmlBuilderOptions, fast_xml_parser.XmlBuilderOptions>>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"csv">;
    variables: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>;
    options: z.ZodOptional<z.ZodCustom<papaparse.UnparseConfig, papaparse.UnparseConfig>>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"cson">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"template">;
    engine: z.ZodDefault<z.ZodEnum<{
        nunjucks: "nunjucks";
        handlebars: "handlebars";
        mustache: "mustache";
    }>>;
    template: z.ZodString;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
}, z.core.$strip>]>;
declare const allTargetsSchema: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"json">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<JsonTargetOptions, JsonTargetOptions>>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"json5">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<Json5TargetOptions, Json5TargetOptions>>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"jsonc">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<JsoncTargetOptions, JsoncTargetOptions>>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"hjson">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<hjson$1.SerializeOptions, hjson$1.SerializeOptions>>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"yaml">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<js_yaml.DumpOptions, js_yaml.DumpOptions>>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"toml">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"ini">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<ini$1.EncodeOptions, ini$1.EncodeOptions>>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"properties">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<PropertiesTargetOptions, PropertiesTargetOptions>>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"env">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"xml">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    options: z.ZodOptional<z.ZodCustom<fast_xml_parser.XmlBuilderOptions, fast_xml_parser.XmlBuilderOptions>>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"csv">;
    variables: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>;
    options: z.ZodOptional<z.ZodCustom<papaparse.UnparseConfig, papaparse.UnparseConfig>>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"cson">;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
}, z.core.$strip>, z.ZodObject<{
    path: z.ZodString;
    schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
    generate_meta: z.ZodDefault<z.ZodBoolean>;
    condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
        maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
            overwrite: "overwrite";
            increment: "increment";
            skip: "skip";
            fail: "fail";
        }>>>;
    }, z.core.$strip>]>>>;
    type: z.ZodLiteral<"template">;
    engine: z.ZodDefault<z.ZodEnum<{
        nunjucks: "nunjucks";
        handlebars: "handlebars";
        mustache: "mustache";
    }>>;
    template: z.ZodString;
    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
}, z.core.$strip>]>>;
type ZodBackupTargetOptions = z.infer<typeof backupTargetOptionsSchema>;
type ZodBackupTarget = z.infer<typeof backupTargetSchema>;
type ZodAnyTarget = z.infer<typeof anyTargetSchema>;
type ZodAllTargets = z.infer<typeof allTargetsSchema>;
type ZodJsonTarget = z.infer<typeof jsonTargetSchema>;
type ZodJson5Target = z.infer<typeof json5TargetSchema>;
type ZodJsoncTarget = z.infer<typeof jsoncTargetSchema>;
type ZodHjsonTarget = z.infer<typeof hjsonTargetSchema>;
type ZodYamlTarget = z.infer<typeof yamlTargetSchema>;
type ZodTomlTarget = z.infer<typeof tomlTargetSchema>;
type ZodIniTarget = z.infer<typeof iniTargetSchema>;
type ZodPropertiesTarget = z.infer<typeof propertiesTargetSchema>;
type ZodEnvTarget = z.infer<typeof envTargetSchema>;
type ZodXmlTarget = z.infer<typeof xmlTargetSchema>;
type ZodCsvTarget = z.infer<typeof csvTargetSchema>;
type ZodCsonTarget = z.infer<typeof csonTargetSchema>;
type ZodTemplateTarget = z.infer<typeof templateTargetSchema>;

/**
 * This file is solely for the UX of defining targets in Axogen.
 * It provides a set of types and factory functions to create target definitions
 * for various data formats and configurations.
 * It is not used to verify the structure of the config file.
 * This is where zod_targets.ts comes in.
 * It only exports some types and the factory functions.
 * Target Types for usage in this package should be used from
 * the zod_targets.ts file.
 */

/**
 * Options for JSON target generation.
 * Uses standard JSON.stringify options for formatting control.
 */
type JsonTargetOptions = {
    replacer?: (number | string)[] | null;
    space?: string | number;
};
/**
 * Options for JSON5 target generation.
 * JSON5 allows comments, trailing commas, and other relaxed JSON syntax.
 */
type Json5TargetOptions = {
    space?: string | number | null;
};
/**
 * Options for JSONC target generation.
 * JSONC is JSON with comments, commonly used in VS Code configuration files.
 */
interface JsoncTargetOptions {
    replacer?: (number | string)[] | null;
    space?: string | number;
}
/**
 * Options for HJSON target generation.
 * HJSON is a human-friendly JSON format with comments and relaxed syntax.
 * References Hjson.SerializeOptions from the hjson library.
 */
type HjsonTargetOptions = hjson__default.SerializeOptions;
/**
 * Options for YAML target generation.
 * References js-yaml DumpOptions for YAML serialization control.
 */
type YamlTargetOptions = js_yaml.DumpOptions;
/**
 * Options for INI target generation.
 * References ini library EncodeOptions for INI file formatting.
 */
type IniTargetOptions = ini$1.EncodeOptions;
/**
 * Options for Properties target generation.
 * Java-style properties file formatting options.
 */
type PropertiesTargetOptions = {
    align?: boolean;
    sort?: boolean;
    whitespace?: boolean;
    platform?: string;
};
/**
 * Options for XML target generation.
 * References fast-xml-parser XmlBuilderOptions for XML formatting control.
 */
type XmlTargetOptions = XmlBuilderOptions;
/**
 * Options for CSV target generation.
 * References papaparse UnparseConfig for CSV formatting and output control.
 */
type CsvTargetOptions = UnparseConfig;
/**
 * Supported template engines for template target generation.
 */
declare const templateTargetEngines: readonly ["nunjucks", "handlebars", "mustache"];
/**
 * Union type of supported template engine names.
 */
type TemplateTargetEngine = (typeof templateTargetEngines)[number];
/**
 * Utility type to infer the TypeScript type from a Zod schema.
 */
type InferVariablesType<TSchema> = TSchema extends z.ZodType<infer T> ? T : TSchema;
/**
 * Utility type to validate that variables match the expected schema type.
 */
type ValidateSchemaVariables<TSchema, TVariables> = TSchema extends z.ZodType<infer Expected> ? TVariables extends Expected ? TVariables : never : TVariables;
/**
 * Base interface for all target definitions.
 * Provides common properties shared across all target types.
 */
interface BaseTargetDefinition<TType extends string, TSchema, TVariables> {
    /** The type of target format to generate */
    type: TType;
    /** Output file path where the target will be written */
    path: string;
    /** Optional Zod schema for validating variables */
    schema?: TSchema;
    /** Variables to use in target generation */
    variables: TVariables;
    /** Whether to generate metadata alongside the target */
    generate_meta?: boolean;
    /** Condition to determine if target should be generated */
    condition?: boolean;
    /** Backup Options. Defaults to false */
    backup?: ZodBackupTarget;
}
/**
 * Target definition for JSON file generation.
 * Generates standard JSON files with optional formatting options.
 */
interface JsonTargetDefinition<TSchema = any, TVariables = InferVariablesType<TSchema>> extends BaseTargetDefinition<"json", TSchema, ValidateSchemaVariables<TSchema, TVariables>> {
    options?: JsonTargetOptions;
}
/**
 * Target definition for JSON5 file generation.
 * Generates JSON5 files with extended syntax support.
 */
interface Json5TargetDefinition<TSchema = any, TVariables = InferVariablesType<TSchema>> extends BaseTargetDefinition<"json5", TSchema, ValidateSchemaVariables<TSchema, TVariables>> {
    options?: Json5TargetOptions;
}
/**
 * Target definition for JSONC file generation.
 * Generates JSON with comments for configuration files.
 */
interface JsoncTargetDefinition<TSchema = any, TVariables = InferVariablesType<TSchema>> extends BaseTargetDefinition<"jsonc", TSchema, ValidateSchemaVariables<TSchema, TVariables>> {
    options?: JsoncTargetOptions;
}
/**
 * Target definition for HJSON file generation.
 * Generates human-friendly JSON with comments and relaxed syntax.
 */
interface HjsonTargetDefinition<TSchema = any, TVariables = InferVariablesType<TSchema>> extends BaseTargetDefinition<"hjson", TSchema, ValidateSchemaVariables<TSchema, TVariables>> {
    options?: HjsonTargetOptions;
}
/**
 * Target definition for YAML file generation.
 * Generates YAML files with configurable formatting options.
 */
interface YamlTargetDefinition<TSchema = any, TVariables = InferVariablesType<TSchema>> extends BaseTargetDefinition<"yaml", TSchema, ValidateSchemaVariables<TSchema, TVariables>> {
    options?: YamlTargetOptions;
}
/**
 * Target definition for TOML file generation.
 * Generates TOML configuration files.
 */
interface TomlTargetDefinition<TSchema = any, TVariables = InferVariablesType<TSchema>> extends BaseTargetDefinition<"toml", TSchema, ValidateSchemaVariables<TSchema, TVariables>> {
}
/**
 * Target definition for INI file generation.
 * Generates INI configuration files with formatting options.
 */
interface IniTargetDefinition<TSchema = any, TVariables = InferVariablesType<TSchema>> extends BaseTargetDefinition<"ini", TSchema, ValidateSchemaVariables<TSchema, TVariables>> {
    options?: IniTargetOptions;
}
/**
 * Target definition for Properties file generation.
 * Generates Java-style properties files.
 */
interface PropertiesTargetDefinition<TSchema = any, TVariables = InferVariablesType<TSchema>> extends BaseTargetDefinition<"properties", TSchema, ValidateSchemaVariables<TSchema, TVariables>> {
    options?: PropertiesTargetOptions;
}
/**
 * Target definition for environment variable file generation.
 * Generates .env files for environment variable configuration.
 */
interface EnvTargetDefinition<TSchema = any, TVariables = InferVariablesType<TSchema>> extends BaseTargetDefinition<"env", TSchema, ValidateSchemaVariables<TSchema, TVariables>> {
}
/**
 * Target definition for XML file generation.
 * Generates XML files with configurable formatting options.
 */
interface XmlTargetDefinition<TSchema = any, TVariables = InferVariablesType<TSchema>> extends BaseTargetDefinition<"xml", TSchema, ValidateSchemaVariables<TSchema, TVariables>> {
    options?: XmlTargetOptions;
}
/**
 * Target definition for CSV file generation.
 * Generates CSV files with configurable formatting and output options.
 */
interface CsvTargetDefinition<TSchema = any, TVariables = InferVariablesType<TSchema>> extends BaseTargetDefinition<"csv", TSchema, ValidateSchemaVariables<TSchema, TVariables>> {
    options?: CsvTargetOptions;
}
/**
 * Target definition for CSON file generation.
 * Generates CoffeeScript Object Notation files.
 */
interface CsonTargetDefinition<TSchema = any, TVariables = InferVariablesType<TSchema>> extends BaseTargetDefinition<"cson", TSchema, ValidateSchemaVariables<TSchema, TVariables>> {
}
/**
 * Target definition for template-based file generation.
 * Generates files using template engines like Nunjucks, Handlebars, or Mustache.
 */
interface TemplateTargetDefinition<TSchema = any, TVariables = InferVariablesType<TSchema>> extends BaseTargetDefinition<"template", TSchema, ValidateSchemaVariables<TSchema, TVariables>> {
    /** Template engine to use for rendering */
    engine: TemplateTargetEngine;
    /** Template path to render with variables */
    template: string;
}
/**
 * Mapping of target type strings to their corresponding target definition interfaces.
 */
interface TargetTypeMap {
    json: JsonTargetDefinition;
    json5: Json5TargetDefinition;
    jsonc: JsoncTargetDefinition;
    hjson: HjsonTargetDefinition;
    yaml: YamlTargetDefinition;
    toml: TomlTargetDefinition;
    ini: IniTargetDefinition;
    properties: PropertiesTargetDefinition;
    env: EnvTargetDefinition;
    xml: XmlTargetDefinition;
    csv: CsvTargetDefinition;
    cson: CsonTargetDefinition;
    template: TemplateTargetDefinition;
}
/**
 * Union type of all possible target definitions.
 */
type AnyTarget = TargetTypeMap[keyof TargetTypeMap];
/**
 * Creates a JSON target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the JSON target
 * @param config.path - The output file path where the JSON will be written
 * @param config.schema - Zod schema for validating variables
 * @param config.variables - Variables to serialize as JSON, validated against schema
 * @param config.options - JSON formatting options (replacer, space)
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns JSON target definition with schema validation
 */
declare function json<TSchema extends z.ZodType>(config: {
    path: string;
    schema: TSchema;
    variables: z.infer<TSchema>;
    options?: JsonTargetOptions;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): JsonTargetDefinition<TSchema, z.infer<TSchema>>;
/**
 * Creates a JSON target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the JSON target
 * @param config.path - The output file path where the JSON will be written
 * @param config.variables - Variables to serialize as JSON
 * @param config.options - JSON formatting options (replacer, space)
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns JSON target definition without schema validation
 */
declare function json<TVariables extends Record<string, any>>(config: {
    path: string;
    variables: TVariables;
    options?: JsonTargetOptions;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): JsonTargetDefinition<TVariables, TVariables>;
/**
 * Creates a JSON5 target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the JSON5 target
 * @param config.path - The output file path where the JSON5 will be written
 * @param config.schema - Zod schema for validating variables
 * @param config.variables - Variables to serialize as JSON5, validated against schema
 * @param config.options - JSON5 formatting options
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns JSON5 target definition with schema validation
 */
declare function json5<TSchema extends z.ZodType>(config: {
    path: string;
    schema: TSchema;
    variables: z.infer<TSchema>;
    options?: Json5TargetOptions;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): Json5TargetDefinition<TSchema, z.infer<TSchema>>;
/**
 * Creates a JSON5 target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the JSON5 target
 * @param config.path - The output file path where the JSON5 will be written
 * @param config.variables - Variables to serialize as JSON5
 * @param config.options - JSON5 formatting options
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns JSON5 target definition without schema validation
 */
declare function json5<TVariables extends Record<string, any>>(config: {
    path: string;
    variables: TVariables;
    options?: Json5TargetOptions;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): Json5TargetDefinition<TVariables, TVariables>;
/**
 * Creates a JSONC target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the JSONC target
 * @param config.path - The output file path where the JSONC will be written
 * @param config.schema - Zod schema for validating variables
 * @param config.variables - Variables to serialize as JSONC, validated against schema
 * @param config.options - JSONC formatting options (replacer, space)
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns JSONC target definition with schema validation
 */
declare function jsonc<TSchema extends z.ZodType>(config: {
    path: string;
    schema: TSchema;
    variables: z.infer<TSchema>;
    options?: JsoncTargetOptions;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): JsoncTargetDefinition<TSchema, z.infer<TSchema>>;
/**
 * Creates a JSONC target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the JSONC target
 * @param config.path - The output file path where the JSONC will be written
 * @param config.variables - Variables to serialize as JSONC
 * @param config.options - JSONC formatting options (replacer, space)
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns JSONC target definition without schema validation
 */
declare function jsonc<TVariables extends Record<string, any>>(config: {
    path: string;
    variables: TVariables;
    options?: JsoncTargetOptions;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): JsoncTargetDefinition<TVariables, TVariables>;
/**
 * Creates an HJSON target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the HJSON target
 * @param config.path - The output file path where the HJSON will be written
 * @param config.schema - Zod schema for validating variables
 * @param config.variables - Variables to serialize as HJSON, validated against schema
 * @param config.options - HJSON serialization options
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns HJSON target definition with schema validation
 */
declare function hjson<TSchema extends z.ZodType>(config: {
    path: string;
    schema: TSchema;
    variables: z.infer<TSchema>;
    options?: HjsonTargetOptions;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): HjsonTargetDefinition<TSchema, z.infer<TSchema>>;
/**
 * Creates an HJSON target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the HJSON target
 * @param config.path - The output file path where the HJSON will be written
 * @param config.variables - Variables to serialize as HJSON
 * @param config.options - HJSON serialization options
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns HJSON target definition without schema validation
 */
declare function hjson<TVariables extends Record<string, any>>(config: {
    path: string;
    variables: TVariables;
    options?: HjsonTargetOptions;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): HjsonTargetDefinition<TVariables, TVariables>;
/**
 * Creates a YAML target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the YAML target
 * @param config.path - The output file path where the YAML will be written
 * @param config.schema - Zod schema for validating variables
 * @param config.variables - Variables to serialize as YAML, validated against schema
 * @param config.options - YAML dump options for formatting control
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns YAML target definition with schema validation
 */
declare function yaml<TSchema extends z.ZodType>(config: {
    path: string;
    schema: TSchema;
    variables: z.infer<TSchema>;
    options?: YamlTargetOptions;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): YamlTargetDefinition<TSchema, z.infer<TSchema>>;
/**
 * Creates a YAML target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the YAML target
 * @param config.path - The output file path where the YAML will be written
 * @param config.variables - Variables to serialize as YAML
 * @param config.options - YAML dump options for formatting control
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns YAML target definition without schema validation
 */
declare function yaml<TVariables extends Record<string, any>>(config: {
    path: string;
    variables: TVariables;
    options?: YamlTargetOptions;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): YamlTargetDefinition<TVariables, TVariables>;
/**
 * Creates a TOML target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the TOML target
 * @param config.path - The output file path where the TOML will be written
 * @param config.schema - Zod schema for validating variables
 * @param config.variables - Variables to serialize as TOML, validated against schema
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns TOML target definition with schema validation
 */
declare function toml<TSchema extends z.ZodType>(config: {
    path: string;
    schema: TSchema;
    variables: z.infer<TSchema>;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): TomlTargetDefinition<TSchema, z.infer<TSchema>>;
/**
 * Creates a TOML target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the TOML target
 * @param config.path - The output file path where the TOML will be written
 * @param config.variables - Variables to serialize as TOML
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns TOML target definition without schema validation
 */
declare function toml<TVariables extends Record<string, any>>(config: {
    path: string;
    variables: TVariables;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): TomlTargetDefinition<TVariables, TVariables>;
/**
 * Creates an INI target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the INI target
 * @param config.path - The output file path where the INI will be written
 * @param config.schema - Zod schema for validating variables
 * @param config.variables - Variables to serialize as INI, validated against schema
 * @param config.options - INI encoding options for formatting control
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns INI target definition with schema validation
 */
declare function ini<TSchema extends z.ZodType>(config: {
    path: string;
    schema: TSchema;
    variables: z.infer<TSchema>;
    options?: IniTargetOptions;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): IniTargetDefinition<TSchema, z.infer<TSchema>>;
/**
 * Creates an INI target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the INI target
 * @param config.path - The output file path where the INI will be written
 * @param config.variables - Variables to serialize as INI
 * @param config.options - INI encoding options for formatting control
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns INI target definition without schema validation
 */
declare function ini<TVariables extends Record<string, any>>(config: {
    path: string;
    variables: TVariables;
    options?: IniTargetOptions;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): IniTargetDefinition<TVariables, TVariables>;
/**
 * Creates a Properties target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the Properties target
 * @param config.path - The output file path where the Properties will be written
 * @param config.schema - Zod schema for validating variables
 * @param config.variables - Variables to serialize as Properties, validated against schema
 * @param config.options - Properties formatting options (align, sort, whitespace, platform)
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns Properties target definition with schema validation
 */
declare function properties<TSchema extends z.ZodType>(config: {
    path: string;
    schema: TSchema;
    variables: z.infer<TSchema>;
    options?: PropertiesTargetOptions;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): PropertiesTargetDefinition<TSchema, z.infer<TSchema>>;
/**
 * Creates a Properties target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the Properties target
 * @param config.path - The output file path where the Properties will be written
 * @param config.variables - Variables to serialize as Properties
 * @param config.options - Properties formatting options (align, sort, whitespace, platform)
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns Properties target definition without schema validation
 */
declare function properties<TVariables extends Record<string, any>>(config: {
    path: string;
    variables: TVariables;
    options?: PropertiesTargetOptions;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): PropertiesTargetDefinition<TVariables, TVariables>;
/**
 * Creates an environment variable target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the environment variable target
 * @param config.path - The output file path where the .env file will be written
 * @param config.schema - Zod schema for validating variables
 * @param config.variables - Variables to serialize as environment variables, validated against schema
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns Environment variable target definition with schema validation
 */
declare function env<TSchema extends z.ZodType>(config: {
    path: string;
    schema: TSchema;
    variables: z.infer<TSchema>;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): EnvTargetDefinition<TSchema, z.infer<TSchema>>;
/**
 * Creates an environment variable target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the environment variable target
 * @param config.path - The output file path where the .env file will be written
 * @param config.variables - Variables to serialize as environment variables
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns Environment variable target definition without schema validation
 */
declare function env<TVariables extends Record<string, any>>(config: {
    path: string;
    variables: TVariables;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): EnvTargetDefinition<TVariables, TVariables>;
/**
 * Creates an XML target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the XML target
 * @param config.path - The output file path where the XML will be written
 * @param config.schema - Zod schema for validating variables
 * @param config.variables - Variables to serialize as XML, validated against schema
 * @param config.options - XML builder options for formatting control
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns XML target definition with schema validation
 */
declare function xml<TSchema extends z.ZodType>(config: {
    path: string;
    schema: TSchema;
    variables: z.infer<TSchema>;
    options?: XmlTargetOptions;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): XmlTargetDefinition<TSchema, z.infer<TSchema>>;
/**
 * Creates an XML target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the XML target
 * @param config.path - The output file path where the XML will be written
 * @param config.variables - Variables to serialize as XML
 * @param config.options - XML builder options for formatting control
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns XML target definition without schema validation
 */
declare function xml<TVariables extends Record<string, any>>(config: {
    path: string;
    variables: TVariables;
    options?: XmlTargetOptions;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): XmlTargetDefinition<TVariables, TVariables>;
/**
 * Creates a CSV target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the CSV target
 * @param config.path - The output file path where the CSV will be written
 * @param config.schema - Zod schema for validating variables
 * @param config.variables - Array of variables to serialize as CSV, validated against schema
 * @param config.options - CSV unparse options for formatting control
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns CSV target definition with schema validation
 */
declare function csv<TSchema extends z.ZodType>(config: {
    path: string;
    schema: TSchema;
    variables: z.infer<TSchema>;
    options?: CsvTargetOptions;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): CsvTargetDefinition<TSchema, z.infer<TSchema>>;
/**
 * Creates a CSV target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the CSV target
 * @param config.path - The output file path where the CSV will be written
 * @param config.variables - Array of variables to serialize as CSV
 * @param config.options - CSV unparse options for formatting control
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns CSV target definition without schema validation
 */
declare function csv<TVariables extends Record<string, any>[]>(config: {
    path: string;
    variables: TVariables;
    options?: CsvTargetOptions;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): CsvTargetDefinition<TVariables, TVariables>;
/**
 * Creates a CSON target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the CSON target
 * @param config.path - The output file path where the CSON will be written
 * @param config.schema - Zod schema for validating variables
 * @param config.variables - Variables to serialize as CSON, validated against schema
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns CSON target definition with schema validation
 */
declare function cson<TSchema extends z.ZodType>(config: {
    path: string;
    schema: TSchema;
    variables: z.infer<TSchema>;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): CsonTargetDefinition<TSchema, z.infer<TSchema>>;
/**
 * Creates a CSON target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the CSON target
 * @param config.path - The output file path where the CSON will be written
 * @param config.variables - Variables to serialize as CSON
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns CSON target definition without schema validation
 */
declare function cson<TVariables extends Record<string, any>>(config: {
    path: string;
    variables: TVariables;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): CsonTargetDefinition<TVariables, TVariables>;
/**
 * Creates a template target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the template target
 * @param config.path - The output file path where the rendered template will be written
 * @param config.schema - Zod schema for validating variables
 * @param config.variables - Variables to use in template rendering, validated against schema
 * @param config.engine - Template engine to use (nunjucks, handlebars, or mustache)
 * @param config.template - Template path to render with variables
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns Template target definition with schema validation
 */
declare function template<TSchema extends z.ZodType>(config: {
    path: string;
    schema: TSchema;
    variables: z.infer<TSchema>;
    engine: TemplateTargetEngine;
    template: string;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): TemplateTargetDefinition<TSchema, z.infer<TSchema>>;
/**
 * Creates a template target definition.
 * Supports both schema-validated and plain object configurations.
 * @param config - Configuration object for the template target
 * @param config.path - The output file path where the rendered template will be written
 * @param config.variables - Variables to use in template rendering
 * @param config.engine - Template engine to use (nunjucks, handlebars, or mustache)
 * @param config.template - Template path to render with variables
 * @param config.generate_meta - Whether to generate metadata alongside the target
 * @param config.condition - Condition to determine if target should be generated
 * @param config.backup - Backup Options. Defaults to false
 * @returns Template target definition without schema validation
 */
declare function template<TVariables extends Record<string, any>>(config: {
    path: string;
    variables: TVariables;
    engine: TemplateTargetEngine;
    template: string;
    generate_meta?: boolean;
    condition?: boolean;
    backup?: ZodBackupTarget;
}): TemplateTargetDefinition<TVariables, TVariables>;

declare const axogenConfigSchema: z.ZodObject<{
    type: z.ZodOptional<z.ZodLiteral<"AxogenConfig">>;
    watch: z.ZodOptional<z.ZodArray<z.ZodString>>;
    targets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
        path: z.ZodString;
        schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
        generate_meta: z.ZodDefault<z.ZodBoolean>;
        condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
            enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
            maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
            onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                overwrite: "overwrite";
                increment: "increment";
                skip: "skip";
                fail: "fail";
            }>>>;
        }, z.core.$strip>]>>>;
        type: z.ZodLiteral<"json">;
        variables: z.ZodRecord<z.ZodString, z.ZodAny>;
        options: z.ZodOptional<z.ZodCustom<JsonTargetOptions, JsonTargetOptions>>;
    }, z.core.$strip>, z.ZodObject<{
        path: z.ZodString;
        schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
        generate_meta: z.ZodDefault<z.ZodBoolean>;
        condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
            enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
            maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
            onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                overwrite: "overwrite";
                increment: "increment";
                skip: "skip";
                fail: "fail";
            }>>>;
        }, z.core.$strip>]>>>;
        type: z.ZodLiteral<"json5">;
        variables: z.ZodRecord<z.ZodString, z.ZodAny>;
        options: z.ZodOptional<z.ZodCustom<Json5TargetOptions, Json5TargetOptions>>;
    }, z.core.$strip>, z.ZodObject<{
        path: z.ZodString;
        schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
        generate_meta: z.ZodDefault<z.ZodBoolean>;
        condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
            enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
            maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
            onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                overwrite: "overwrite";
                increment: "increment";
                skip: "skip";
                fail: "fail";
            }>>>;
        }, z.core.$strip>]>>>;
        type: z.ZodLiteral<"jsonc">;
        variables: z.ZodRecord<z.ZodString, z.ZodAny>;
        options: z.ZodOptional<z.ZodCustom<JsoncTargetOptions, JsoncTargetOptions>>;
    }, z.core.$strip>, z.ZodObject<{
        path: z.ZodString;
        schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
        generate_meta: z.ZodDefault<z.ZodBoolean>;
        condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
            enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
            maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
            onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                overwrite: "overwrite";
                increment: "increment";
                skip: "skip";
                fail: "fail";
            }>>>;
        }, z.core.$strip>]>>>;
        type: z.ZodLiteral<"hjson">;
        variables: z.ZodRecord<z.ZodString, z.ZodAny>;
        options: z.ZodOptional<z.ZodCustom<hjson$1.SerializeOptions, hjson$1.SerializeOptions>>;
    }, z.core.$strip>, z.ZodObject<{
        path: z.ZodString;
        schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
        generate_meta: z.ZodDefault<z.ZodBoolean>;
        condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
            enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
            maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
            onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                overwrite: "overwrite";
                increment: "increment";
                skip: "skip";
                fail: "fail";
            }>>>;
        }, z.core.$strip>]>>>;
        type: z.ZodLiteral<"yaml">;
        variables: z.ZodRecord<z.ZodString, z.ZodAny>;
        options: z.ZodOptional<z.ZodCustom<js_yaml.DumpOptions, js_yaml.DumpOptions>>;
    }, z.core.$strip>, z.ZodObject<{
        path: z.ZodString;
        schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
        generate_meta: z.ZodDefault<z.ZodBoolean>;
        condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
            enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
            maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
            onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                overwrite: "overwrite";
                increment: "increment";
                skip: "skip";
                fail: "fail";
            }>>>;
        }, z.core.$strip>]>>>;
        type: z.ZodLiteral<"toml">;
        variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    }, z.core.$strip>, z.ZodObject<{
        path: z.ZodString;
        schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
        generate_meta: z.ZodDefault<z.ZodBoolean>;
        condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
            enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
            maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
            onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                overwrite: "overwrite";
                increment: "increment";
                skip: "skip";
                fail: "fail";
            }>>>;
        }, z.core.$strip>]>>>;
        type: z.ZodLiteral<"ini">;
        variables: z.ZodRecord<z.ZodString, z.ZodAny>;
        options: z.ZodOptional<z.ZodCustom<ini$1.EncodeOptions, ini$1.EncodeOptions>>;
    }, z.core.$strip>, z.ZodObject<{
        path: z.ZodString;
        schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
        generate_meta: z.ZodDefault<z.ZodBoolean>;
        condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
            enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
            maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
            onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                overwrite: "overwrite";
                increment: "increment";
                skip: "skip";
                fail: "fail";
            }>>>;
        }, z.core.$strip>]>>>;
        type: z.ZodLiteral<"properties">;
        variables: z.ZodRecord<z.ZodString, z.ZodAny>;
        options: z.ZodOptional<z.ZodCustom<PropertiesTargetOptions, PropertiesTargetOptions>>;
    }, z.core.$strip>, z.ZodObject<{
        path: z.ZodString;
        schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
        generate_meta: z.ZodDefault<z.ZodBoolean>;
        condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
            enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
            maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
            onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                overwrite: "overwrite";
                increment: "increment";
                skip: "skip";
                fail: "fail";
            }>>>;
        }, z.core.$strip>]>>>;
        type: z.ZodLiteral<"env">;
        variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    }, z.core.$strip>, z.ZodObject<{
        path: z.ZodString;
        schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
        generate_meta: z.ZodDefault<z.ZodBoolean>;
        condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
            enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
            maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
            onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                overwrite: "overwrite";
                increment: "increment";
                skip: "skip";
                fail: "fail";
            }>>>;
        }, z.core.$strip>]>>>;
        type: z.ZodLiteral<"xml">;
        variables: z.ZodRecord<z.ZodString, z.ZodAny>;
        options: z.ZodOptional<z.ZodCustom<fast_xml_parser.XmlBuilderOptions, fast_xml_parser.XmlBuilderOptions>>;
    }, z.core.$strip>, z.ZodObject<{
        path: z.ZodString;
        schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
        generate_meta: z.ZodDefault<z.ZodBoolean>;
        condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
            enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
            maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
            onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                overwrite: "overwrite";
                increment: "increment";
                skip: "skip";
                fail: "fail";
            }>>>;
        }, z.core.$strip>]>>>;
        type: z.ZodLiteral<"csv">;
        variables: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>;
        options: z.ZodOptional<z.ZodCustom<papaparse.UnparseConfig, papaparse.UnparseConfig>>;
    }, z.core.$strip>, z.ZodObject<{
        path: z.ZodString;
        schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
        generate_meta: z.ZodDefault<z.ZodBoolean>;
        condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
            enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
            maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
            onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                overwrite: "overwrite";
                increment: "increment";
                skip: "skip";
                fail: "fail";
            }>>>;
        }, z.core.$strip>]>>>;
        type: z.ZodLiteral<"cson">;
        variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    }, z.core.$strip>, z.ZodObject<{
        path: z.ZodString;
        schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
        generate_meta: z.ZodDefault<z.ZodBoolean>;
        condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
            enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
            maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
            onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                overwrite: "overwrite";
                increment: "increment";
                skip: "skip";
                fail: "fail";
            }>>>;
        }, z.core.$strip>]>>>;
        type: z.ZodLiteral<"template">;
        engine: z.ZodDefault<z.ZodEnum<{
            nunjucks: "nunjucks";
            handlebars: "handlebars";
            mustache: "mustache";
        }>>;
        template: z.ZodString;
        variables: z.ZodRecord<z.ZodString, z.ZodAny>;
    }, z.core.$strip>]>>>;
    commands: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<AnyCommand, unknown, z.core.$ZodTypeInternals<AnyCommand, unknown>>>>;
}, z.core.$strip>;
type ZodAxogenConfig = z.infer<typeof axogenConfigSchema>;

interface AxogenConfig<TTargets extends Record<string, AnyTarget> = Record<string, AnyTarget>> {
    watch?: string[];
    targets?: TTargets;
    commands?: Record<string, AnyCommand<TypeOptions, TypeArgs, TTargets>>;
}
type Variables = Record<string, unknown>;
type ConfigInput = Variables | AxogenConfig | ZodAxogenConfig;

/**
 * This file is solely for the UX of defining commands in Axogen.
 * It is not used for Zod validation. (similar to targets.ts)
 */

type TypeOptions = Record<string, z.ZodType>;
type TypeArgs = Record<string, z.ZodType>;
type TypeTargets = Record<string, AnyTarget>;
interface GlobalCommandContext {
    cwd: string;
    process_env: Record<string, any>;
    verbose: boolean;
}
interface CommandContext<TOptions extends TypeOptions = TypeOptions, TArgs extends TypeArgs = TypeArgs, TTargets extends TypeTargets = TypeTargets> {
    options: {
        [K in keyof TOptions]: z.infer<TOptions[K]>;
    };
    args: {
        [K in keyof TArgs]: z.infer<TArgs[K]>;
    };
    global: GlobalCommandContext;
    config: AxogenConfig<TTargets>;
}
interface SimpleCommandContext<TTargets extends TypeTargets = TypeTargets> {
    global: GlobalCommandContext;
    config: AxogenConfig<TTargets>;
}
/**
 * THIS IS ONLY FOR ZOD VALIDATION.
 * Dont use this export in your code.
 */
type CommandFunction<TOptions extends TypeOptions = TypeOptions, TArgs extends TypeArgs = TypeArgs, TTargets extends TypeTargets = TypeTargets> = (context: CommandContext<TOptions, TArgs, TTargets>) => void | Promise<void>;
/**
 * THIS IS ONLY FOR ZOD VALIDATION.
 * Dont use this export in your code.
 */
type SimpleCommandFunction<TTargets extends TypeTargets = TypeTargets> = (context: SimpleCommandContext<TTargets>) => void | Promise<void>;
interface CommandDefinition<TType extends string> {
    type: TType;
    help?: string;
}
interface StringCommandDefinition extends CommandDefinition<"string"> {
    command: string;
}
interface GroupCommandDefinition<TOptions extends TypeOptions = TypeOptions, TArgs extends TypeArgs = TypeArgs, TTargets extends TypeTargets = TypeTargets> extends CommandDefinition<"group"> {
    commands: Record<string, AnyCommand<TOptions, TArgs, TTargets>>;
}
interface AdvancedCommandDefinition<TOptions extends TypeOptions = TypeOptions, TArgs extends TypeArgs = TypeArgs, TTargets extends TypeTargets = TypeTargets> extends CommandDefinition<"advanced"> {
    options?: TOptions;
    args?: TArgs;
    exec: CommandFunction<TOptions, TArgs, TTargets>;
}
type AnyCommand<TOptions extends TypeOptions = TypeOptions, TArgs extends TypeArgs = TypeArgs, TTargets extends TypeTargets = TypeTargets> = string | SimpleCommandFunction<TTargets> | StringCommandDefinition | GroupCommandDefinition<TOptions, TArgs, TTargets> | AdvancedCommandDefinition<TOptions, TArgs, TTargets> | AdvancedCommandDefinition<any, any, TTargets>;
/**
 * Create a string command definition that executes a shell command.
 * @param config - Configuration object for the command
 * @param config.command - Shell command string to execute
 * @param config.help - Optional help text describing what the command does
 * @returns String command definition
 */
declare function cmd(config: {
    command: string;
    help?: string;
}): StringCommandDefinition;
/**
 * Create an advanced command definition with TypeScript execution function.
 * Supports typed options, arguments, and full access to configuration and context.
 * @param config - Configuration object for the advanced command
 * @param config.exec - TypeScript function to execute when command is run. Receives full context including args, options, and config
 * @param config.options - Optional Zod schema definitions for command-line options (flags like --verbose)
 * @param config.args - Optional Zod schema definitions for command arguments (positional parameters)
 * @param config.help - Optional help text describing what the command does
 * @returns Advanced command definition with full type safety
 */
declare function cmd<TOptions extends TypeOptions = TypeOptions, TArgs extends TypeArgs = TypeArgs, TTargets extends TypeTargets = TypeTargets>(config: {
    exec: CommandFunction<TOptions, TArgs, TTargets>;
    options?: TOptions;
    args?: TArgs;
    help?: string;
}): AdvancedCommandDefinition<TOptions, TArgs, TTargets>;
/**
 * Create a group command definition that contains sub-commands.
 * Allows organizing related commands under a common namespace.
 * @param config - Configuration object for the command group
 * @param config.commands - Record of sub-commands that belong to this group
 * @param config.help - Optional help text describing what the command group does
 * @returns Group command definition containing the specified sub-commands
 */
declare function group<TOptions extends TypeOptions, TArgs extends TypeArgs, TTargets extends TypeTargets>(config: {
    commands: Record<string, AnyCommand<TOptions, TArgs, TTargets>>;
    help?: string;
}): GroupCommandDefinition<TOptions, TArgs, TTargets>;

declare const globalCommandContextSchema: z.ZodObject<{
    cwd: z.ZodString;
    process_env: z.ZodRecord<z.ZodString, z.ZodAny>;
    verbose: z.ZodBoolean;
}, z.core.$strip>;
declare const zodTypeSchema: z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
declare const commandContextSchema: z.ZodObject<{
    options: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>>;
    args: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>>;
    global: z.ZodObject<{
        cwd: z.ZodString;
        process_env: z.ZodRecord<z.ZodString, z.ZodAny>;
        verbose: z.ZodBoolean;
    }, z.core.$strip>;
    config: z.ZodObject<{
        type: z.ZodOptional<z.ZodLiteral<"AxogenConfig">>;
        watch: z.ZodOptional<z.ZodArray<z.ZodString>>;
        targets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"json">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
            options: z.ZodOptional<z.ZodCustom<JsonTargetOptions, JsonTargetOptions>>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"json5">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
            options: z.ZodOptional<z.ZodCustom<Json5TargetOptions, Json5TargetOptions>>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"jsonc">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
            options: z.ZodOptional<z.ZodCustom<JsoncTargetOptions, JsoncTargetOptions>>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"hjson">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
            options: z.ZodOptional<z.ZodCustom<hjson$1.SerializeOptions, hjson$1.SerializeOptions>>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"yaml">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
            options: z.ZodOptional<z.ZodCustom<js_yaml.DumpOptions, js_yaml.DumpOptions>>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"toml">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"ini">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
            options: z.ZodOptional<z.ZodCustom<ini$1.EncodeOptions, ini$1.EncodeOptions>>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"properties">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
            options: z.ZodOptional<z.ZodCustom<PropertiesTargetOptions, PropertiesTargetOptions>>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"env">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"xml">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
            options: z.ZodOptional<z.ZodCustom<fast_xml_parser.XmlBuilderOptions, fast_xml_parser.XmlBuilderOptions>>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"csv">;
            variables: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>;
            options: z.ZodOptional<z.ZodCustom<papaparse.UnparseConfig, papaparse.UnparseConfig>>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"cson">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"template">;
            engine: z.ZodDefault<z.ZodEnum<{
                nunjucks: "nunjucks";
                handlebars: "handlebars";
                mustache: "mustache";
            }>>;
            template: z.ZodString;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
        }, z.core.$strip>]>>>;
        commands: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<AnyCommand, unknown, z.core.$ZodTypeInternals<AnyCommand, unknown>>>>;
    }, z.core.$strip>;
}, z.core.$strip>;
declare const simpleCommandContextSchema: z.ZodObject<{
    global: z.ZodObject<{
        cwd: z.ZodString;
        process_env: z.ZodRecord<z.ZodString, z.ZodAny>;
        verbose: z.ZodBoolean;
    }, z.core.$strip>;
    config: z.ZodObject<{
        type: z.ZodOptional<z.ZodLiteral<"AxogenConfig">>;
        watch: z.ZodOptional<z.ZodArray<z.ZodString>>;
        targets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"json">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
            options: z.ZodOptional<z.ZodCustom<JsonTargetOptions, JsonTargetOptions>>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"json5">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
            options: z.ZodOptional<z.ZodCustom<Json5TargetOptions, Json5TargetOptions>>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"jsonc">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
            options: z.ZodOptional<z.ZodCustom<JsoncTargetOptions, JsoncTargetOptions>>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"hjson">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
            options: z.ZodOptional<z.ZodCustom<hjson$1.SerializeOptions, hjson$1.SerializeOptions>>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"yaml">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
            options: z.ZodOptional<z.ZodCustom<js_yaml.DumpOptions, js_yaml.DumpOptions>>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"toml">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"ini">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
            options: z.ZodOptional<z.ZodCustom<ini$1.EncodeOptions, ini$1.EncodeOptions>>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"properties">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
            options: z.ZodOptional<z.ZodCustom<PropertiesTargetOptions, PropertiesTargetOptions>>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"env">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"xml">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
            options: z.ZodOptional<z.ZodCustom<fast_xml_parser.XmlBuilderOptions, fast_xml_parser.XmlBuilderOptions>>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"csv">;
            variables: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>;
            options: z.ZodOptional<z.ZodCustom<papaparse.UnparseConfig, papaparse.UnparseConfig>>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"cson">;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
        }, z.core.$strip>, z.ZodObject<{
            path: z.ZodString;
            schema: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
            generate_meta: z.ZodDefault<z.ZodBoolean>;
            condition: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            backup: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                folder: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                maxBackups: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                onConflict: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                    overwrite: "overwrite";
                    increment: "increment";
                    skip: "skip";
                    fail: "fail";
                }>>>;
            }, z.core.$strip>]>>>;
            type: z.ZodLiteral<"template">;
            engine: z.ZodDefault<z.ZodEnum<{
                nunjucks: "nunjucks";
                handlebars: "handlebars";
                mustache: "mustache";
            }>>;
            template: z.ZodString;
            variables: z.ZodRecord<z.ZodString, z.ZodAny>;
        }, z.core.$strip>]>>>;
        commands: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<AnyCommand, unknown, z.core.$ZodTypeInternals<AnyCommand, unknown>>>>;
    }, z.core.$strip>;
}, z.core.$strip>;
declare const stringCommandSchema: z.ZodObject<{
    type: z.ZodLiteral<"string">;
    help: z.ZodOptional<z.ZodString>;
    command: z.ZodString;
}, z.core.$strip>;
declare const groupCommandSchema: z.ZodObject<{
    type: z.ZodLiteral<"group">;
    help: z.ZodOptional<z.ZodString>;
    commands: z.ZodRecord<z.ZodString, z.ZodLazy<z.ZodType<AnyCommand, unknown, z.core.$ZodTypeInternals<AnyCommand, unknown>>>>;
}, z.core.$strip>;
declare const advancedCommandSchema: z.ZodObject<{
    type: z.ZodLiteral<"advanced">;
    help: z.ZodOptional<z.ZodString>;
    options: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>>;
    args: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>>;
    exec: z.ZodCustom<CommandFunction, CommandFunction>;
}, z.core.$strip>;
declare const simpleStringCommandSchema: z.ZodString;
declare const simpleCommandFunctionSchema: z.ZodCustom<SimpleCommandFunction, SimpleCommandFunction>;
declare const anyCommandSchema: z.ZodType<AnyCommand>;
type ZodAnyCommand = z.infer<typeof anyCommandSchema>;
type ZodStringCommand = z.infer<typeof stringCommandSchema>;
type ZodGroupCommand = z.infer<typeof groupCommandSchema>;
type ZodAdvancedCommand = z.infer<typeof advancedCommandSchema>;
type ZodSimpleStringCommand = z.infer<typeof simpleStringCommandSchema>;
type ZodSimpleCommandFunction = z.infer<typeof simpleCommandFunctionSchema>;
type ZodCommandContext = z.infer<typeof commandContextSchema>;
type ZodSimpleCommandContext = z.infer<typeof simpleCommandContextSchema>;
type ZodGlobalCommandContext = z.infer<typeof globalCommandContextSchema>;

/**
 * Define and validate an Axogen configuration.
 * This is the primary function users call to create their configuration.
 * Provides full type safety and validation using Zod schemas.
 * @param config - The Axogen configuration object with targets and commands
 * @returns Validated configuration object
 * @throws Error if configuration validation fails
 */
declare function defineConfig<TTargets extends Record<string, AnyTarget>>(config: AxogenConfig<TTargets>): ZodAxogenConfig;
/**
 * Extend an existing Axogen configuration with additional targets or commands.
 * NOTE: This function merges the source configuration with the extension,
 * in case of conflicts, the extension will ***OVERRIDE*** the source.
 * @param source - The source Axogen configuration to extend
 * @param extension - The Axogen configuration extension to merge with the source
 */
declare function extendConfig<TTargets extends Record<string, AnyTarget>>(source: ZodAxogenConfig, extension: AxogenConfig<TTargets>): {
    type?: "AxogenConfig" | undefined;
    watch?: string[] | undefined;
    targets?: Record<string, {
        path: string;
        generate_meta: boolean;
        type: "json";
        variables: Record<string, any>;
        schema?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
        condition?: boolean | undefined;
        backup?: boolean | {
            enabled?: boolean | undefined;
            folder?: string | undefined;
            maxBackups?: number | undefined;
            onConflict?: "overwrite" | "increment" | "skip" | "fail" | undefined;
        } | undefined;
        options?: JsonTargetOptions | undefined;
    } | {
        path: string;
        generate_meta: boolean;
        type: "json5";
        variables: Record<string, any>;
        schema?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
        condition?: boolean | undefined;
        backup?: boolean | {
            enabled?: boolean | undefined;
            folder?: string | undefined;
            maxBackups?: number | undefined;
            onConflict?: "overwrite" | "increment" | "skip" | "fail" | undefined;
        } | undefined;
        options?: Json5TargetOptions | undefined;
    } | {
        path: string;
        generate_meta: boolean;
        type: "jsonc";
        variables: Record<string, any>;
        schema?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
        condition?: boolean | undefined;
        backup?: boolean | {
            enabled?: boolean | undefined;
            folder?: string | undefined;
            maxBackups?: number | undefined;
            onConflict?: "overwrite" | "increment" | "skip" | "fail" | undefined;
        } | undefined;
        options?: JsoncTargetOptions | undefined;
    } | {
        path: string;
        generate_meta: boolean;
        type: "hjson";
        variables: Record<string, any>;
        schema?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
        condition?: boolean | undefined;
        backup?: boolean | {
            enabled?: boolean | undefined;
            folder?: string | undefined;
            maxBackups?: number | undefined;
            onConflict?: "overwrite" | "increment" | "skip" | "fail" | undefined;
        } | undefined;
        options?: hjson$1.SerializeOptions | undefined;
    } | {
        path: string;
        generate_meta: boolean;
        type: "yaml";
        variables: Record<string, any>;
        schema?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
        condition?: boolean | undefined;
        backup?: boolean | {
            enabled?: boolean | undefined;
            folder?: string | undefined;
            maxBackups?: number | undefined;
            onConflict?: "overwrite" | "increment" | "skip" | "fail" | undefined;
        } | undefined;
        options?: js_yaml.DumpOptions | undefined;
    } | {
        path: string;
        generate_meta: boolean;
        type: "toml";
        variables: Record<string, any>;
        schema?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
        condition?: boolean | undefined;
        backup?: boolean | {
            enabled?: boolean | undefined;
            folder?: string | undefined;
            maxBackups?: number | undefined;
            onConflict?: "overwrite" | "increment" | "skip" | "fail" | undefined;
        } | undefined;
    } | {
        path: string;
        generate_meta: boolean;
        type: "ini";
        variables: Record<string, any>;
        schema?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
        condition?: boolean | undefined;
        backup?: boolean | {
            enabled?: boolean | undefined;
            folder?: string | undefined;
            maxBackups?: number | undefined;
            onConflict?: "overwrite" | "increment" | "skip" | "fail" | undefined;
        } | undefined;
        options?: ini$1.EncodeOptions | undefined;
    } | {
        path: string;
        generate_meta: boolean;
        type: "properties";
        variables: Record<string, any>;
        schema?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
        condition?: boolean | undefined;
        backup?: boolean | {
            enabled?: boolean | undefined;
            folder?: string | undefined;
            maxBackups?: number | undefined;
            onConflict?: "overwrite" | "increment" | "skip" | "fail" | undefined;
        } | undefined;
        options?: PropertiesTargetOptions | undefined;
    } | {
        path: string;
        generate_meta: boolean;
        type: "env";
        variables: Record<string, any>;
        schema?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
        condition?: boolean | undefined;
        backup?: boolean | {
            enabled?: boolean | undefined;
            folder?: string | undefined;
            maxBackups?: number | undefined;
            onConflict?: "overwrite" | "increment" | "skip" | "fail" | undefined;
        } | undefined;
    } | {
        path: string;
        generate_meta: boolean;
        type: "xml";
        variables: Record<string, any>;
        schema?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
        condition?: boolean | undefined;
        backup?: boolean | {
            enabled?: boolean | undefined;
            folder?: string | undefined;
            maxBackups?: number | undefined;
            onConflict?: "overwrite" | "increment" | "skip" | "fail" | undefined;
        } | undefined;
        options?: fast_xml_parser.XmlBuilderOptions | undefined;
    } | {
        path: string;
        generate_meta: boolean;
        type: "csv";
        variables: Record<string, any>[];
        schema?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
        condition?: boolean | undefined;
        backup?: boolean | {
            enabled?: boolean | undefined;
            folder?: string | undefined;
            maxBackups?: number | undefined;
            onConflict?: "overwrite" | "increment" | "skip" | "fail" | undefined;
        } | undefined;
        options?: papaparse.UnparseConfig | undefined;
    } | {
        path: string;
        generate_meta: boolean;
        type: "cson";
        variables: Record<string, any>;
        schema?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
        condition?: boolean | undefined;
        backup?: boolean | {
            enabled?: boolean | undefined;
            folder?: string | undefined;
            maxBackups?: number | undefined;
            onConflict?: "overwrite" | "increment" | "skip" | "fail" | undefined;
        } | undefined;
    } | {
        path: string;
        generate_meta: boolean;
        type: "template";
        engine: "nunjucks" | "handlebars" | "mustache";
        template: string;
        variables: Record<string, any>;
        schema?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
        condition?: boolean | undefined;
        backup?: boolean | {
            enabled?: boolean | undefined;
            folder?: string | undefined;
            maxBackups?: number | undefined;
            onConflict?: "overwrite" | "increment" | "skip" | "fail" | undefined;
        } | undefined;
    }> | undefined;
    commands?: Record<string, AnyCommand> | undefined;
};

/**
 * Execute a shell command and capture output.
 * Runs the command in a child process and returns stdout, stderr, and exit code.
 * @param command - Shell command to execute
 * @param options - Execution options including working directory and environment variables
 * @returns Promise resolving to command output and exit code
 */
declare function executeCommand(command: string, options?: {
    cwd?: string;
    env?: NodeJS.ProcessEnv;
}): Promise<{
    stdout: string;
    stderr: string;
    exitCode: number;
}>;
interface LiveExecOptions {
    cwd?: string;
    env?: NodeJS.ProcessEnv;
    /** Prefix for live output lines */
    outputPrefix?: string;
    /** Whether this command needs interactive input (default: auto-detect) */
    interactive?: boolean;
}
interface LiveExecResult {
    exitCode: number;
    /** Whether the command was terminated by user action */
    wasTerminated: boolean;
}
/**
 * Execute a shell command with live input/output streaming.
 * Supports interactive commands and provides real-time output with proper signal handling.
 * Automatically detects interactive commands and enables stdin forwarding when appropriate.
 * @param command - Shell command to execute
 * @param options - Execution options including working directory, environment, and interactivity settings
 * @returns Promise resolving to exit code and termination status
 */
declare function liveExec(command: string, options?: LiveExecOptions): Promise<LiveExecResult>;
declare const exec: typeof executeCommand;

/**
 * Configuration loading utilities for Axogen.
 * This module provides functionality to load, validate, and process configuration files
 * from TypeScript or JavaScript sources using Jiti for TypeScript compilation.
 */

/**
 * Load configuration - convenience function that uses the singleton ConfigLoader instance.
 * This is the primary function users should call to load their Axogen configuration.
 * @param configPath - Optional path to configuration file
 * @returns Promise that resolves to validated Axogen configuration
 */
declare function loadConfig(configPath?: string): Promise<ZodAxogenConfig>;

interface LoadEnvConfig extends DotenvConfigOptions {
    /**
     * Whether to exit the process on validation error
     * @default true
     */
    exitOnError?: boolean;
    /**
     * Whether to suppress success messages
     * @default false
     */
    silent?: boolean;
    /**
     * Path to the .env file
     * @default ".env.axogen"
     */
    path?: string;
    /**
     * Whether to suppress dotenv messages
     * @default true
     */
    quiet?: boolean;
    /**
     * Encoding of the .env file
     * @default "utf8"
     */
    encoding?: BufferEncoding;
}
/**
 * Load and validate environment variables using dotenvx and a Zod schema.
 * IMPORTANT: Environment variables are injected into process.env BEFORE validation.
 * If validation fails, the program will exit (if configured to do so), but the variables
 * will already be available in process.env.
 * @param schema - Zod schema to validate environment variables against
 * @param envConfig - Configuration options for loading environment variables
 * @returns Validated environment variables matching the schema
 * @throws Error if validation fails or configuration is invalid
 */
declare function loadEnv<TSchema extends z$1.ZodType>(schema: TSchema, envConfig?: LoadEnvConfig): z$1.infer<TSchema>;

/**
 * Research-based secret detection
 */

declare const unsafeSchema: z.ZodObject<{
    _marker: z.ZodLiteral<"unsafe">;
    value: z.ZodString;
    reason: z.ZodString;
}, z.core.$strict>;
/**
 * Mark a string value as safe to bypass Axogen's secret detection system.
 * This allows you to explicitly indicate that a value that looks like a secret
 * is actually safe to write to files that are not git-ignored.
 * @param value - The string value that looks like a secret but is actually safe
 * @param reason - Description of why this value is safe despite appearing to be a secret
 * @returns Wrapped value that bypasses Axogen's secret detection checks
 */
declare function unsafe(value: string, reason: string): z.infer<typeof unsafeSchema>;

declare function parseTomlFile(filePath: string): TOML.JsonMap;

declare function parseJson5File(filePath: string): any;

declare function parseJsoncFile(filePath: string): any;

declare function parseHjsonFile(filePath: string): any;

declare function parseYamlFile(filePath: string): unknown;

declare function parseIniFile(filePath: string): {
    [key: string]: any;
};

declare function parsePropertiesFile(filePath: string): Record<string, string>;

declare function parseEnvFile(filePath: string): _dotenvx_dotenvx.DotenvParseOutput;

declare function parseXmlFile(filePath: string): any;

declare function parseCsvFile(filePath: string): any[];

declare const txtSchema: z.ZodObject<{
    content: z.ZodString;
}, z.core.$strip>;
declare function parseTxtFile(filePath: string): {
    content: string;
};

declare function parseCsonFile(filePath: string): any;

declare const SupportedLoadFileTypes: string[];
type SupportedLoadFileTypesType = (typeof SupportedLoadFileTypes)[number];
/**
 * Load a configuration file and validate it against an optional schema.
 *
 * @param filePath - The path to the configuration file.
 * @param type - The type of the file to load, which determines the parsing method.
 * @param schema - Optional Zod schema to validate the loaded data.
 * @returns A promise that resolves to the parsed and validated data.
 */
declare function loadFile<TSchema extends z.ZodType>(filePath: string, type: SupportedLoadFileTypesType, schema: TSchema): z.infer<TSchema>;
declare function loadFile(filePath: string, type: SupportedLoadFileTypesType): Record<string, unknown>;

/**
 * Main entry point for Axogen - a TypeScript-native configuration and task management library.
 * This module provides all public APIs and utilities for working with Axogen configurations,
 * commands, and target generation.
 */
/**
 * Runs the CLI with the provided arguments (or process.argv if not provided).
 * This function can be imported and called from other packages.
 * @param argv Optional array of command line arguments
 */
declare function runCLI(argv?: string[]): Promise<void>;

export { type AdvancedCommandDefinition, type AnyCommand, type AnyTarget, type AxogenConfig, type CommandContext, type CommandFunction, type ConfigInput, type CsonTargetDefinition, type CsvTargetDefinition, type CsvTargetOptions, type EnvTargetDefinition, type GlobalCommandContext, type GroupCommandDefinition, type HjsonTargetDefinition, type HjsonTargetOptions, type IniTargetDefinition, type IniTargetOptions, type Json5TargetDefinition, type Json5TargetOptions, type JsonTargetDefinition, type JsonTargetOptions, type JsoncTargetDefinition, type JsoncTargetOptions, type PropertiesTargetDefinition, type PropertiesTargetOptions, type SimpleCommandContext, type SimpleCommandFunction, type StringCommandDefinition, SupportedLoadFileTypes, type SupportedLoadFileTypesType, type TargetTypeMap, type TemplateTargetDefinition, type TemplateTargetEngine, type TomlTargetDefinition, type TypeArgs, type TypeOptions, type TypeTargets, type Variables, type XmlTargetDefinition, type XmlTargetOptions, type YamlTargetDefinition, type YamlTargetOptions, type ZodAdvancedCommand, type ZodAllTargets, type ZodAnyCommand, type ZodAnyTarget, type ZodAxogenConfig, type ZodBackupTarget, type ZodBackupTargetOptions, type ZodCommandContext, type ZodCsonTarget, type ZodCsvTarget, type ZodEnvTarget, type ZodGlobalCommandContext, type ZodGroupCommand, type ZodHjsonTarget, type ZodIniTarget, type ZodJson5Target, type ZodJsonTarget, type ZodJsoncTarget, type ZodPropertiesTarget, type ZodSimpleCommandContext, type ZodSimpleCommandFunction, type ZodSimpleStringCommand, type ZodStringCommand, type ZodTemplateTarget, type ZodTomlTarget, type ZodXmlTarget, type ZodYamlTarget, advancedCommandSchema, allTargetsSchema, anyCommandSchema, anyTargetSchema, axogenConfigSchema, backupTargetOptionsSchema, backupTargetSchema, cmd, commandContextSchema, cson, csonTargetSchema, csv, csvTargetSchema, defineConfig, env, envTargetSchema, exec, executeCommand, extendConfig, globalCommandContextSchema, group, groupCommandSchema, hjson, hjsonTargetSchema, ini, iniTargetSchema, json, json5, json5TargetSchema, jsonTargetSchema, jsonc, jsoncTargetSchema, liveExec, loadConfig, loadEnv, loadFile, parseCsonFile, parseCsvFile, parseEnvFile, parseHjsonFile, parseIniFile, parseJson5File, parseJsoncFile, parsePropertiesFile, parseTomlFile, parseTxtFile, parseXmlFile, parseYamlFile, properties, propertiesTargetSchema, runCLI, simpleCommandContextSchema, simpleCommandFunctionSchema, simpleStringCommandSchema, stringCommandSchema, template, templateTargetEngines, templateTargetSchema, toml, tomlTargetSchema, txtSchema, unsafe, xml, xmlTargetSchema, yaml, yamlTargetSchema, zodTypeSchema };