@wrkspace-co/env 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,707 @@
+import { E as EnvValidationIssue, a as EnvTarget, b as EnvSchema, P as PrefixPolicy, c as EnvScope, d as EnvVariableDefinition, D as DeprecatedMetadata, e as ProviderMapping } from './plugin-Dj0BMNPC.js';
+export { B as BooleanVariableDefinition, C as CreateEnvOptions, f as EnumVariableDefinition, g as EnvKind, h as EnvValidationError, i as EnvVariableConfig, j as EnvVariableMetadata, J as JsonVariableDefinition, N as NumberVariableDefinition, k as PrefixPolicyContext, l as PrefixPolicyIssue, R as RuntimeEnv, S as StringVariableDefinition, U as UrlVariableDefinition, V as ValidationSeverity, m as boolean, n as builders, o as createAirlockProgram, p as createEnv, q as defineSchema, r as enum, s as formatValidationIssues, t as json, u as number, v as plugin, w as prefixPolicies, x as register, y as string, z as url } from './plugin-Dj0BMNPC.js';
+import 'commander';
+
+interface DriftIssue extends EnvValidationIssue {
+    source?: string;
+}
+interface DriftSummary {
+    total: number;
+    errors: number;
+    warnings: number;
+}
+interface DriftResult {
+    target: EnvTarget;
+    summary: DriftSummary;
+    issues: DriftIssue[];
+}
+interface DriftOptions {
+    target: EnvTarget;
+    values: Record<string, string | undefined>;
+    source?: string;
+    allowUnknown?: boolean;
+}
+declare function detectDrift(schema: EnvSchema, options: DriftOptions): DriftResult;
+
+type ExitCode$6 = 0 | 1;
+interface AuditTargetResult {
+    target: EnvTarget;
+    inspectedFiles: string[];
+    summary: {
+        total: number;
+        errors: number;
+        warnings: number;
+    };
+    issues: DriftIssue[];
+}
+interface AuditCommandResult {
+    ok: boolean;
+    exitCode: ExitCode$6;
+    schemaPath: string;
+    summary: {
+        total: number;
+        errors: number;
+        warnings: number;
+    };
+    targets: AuditTargetResult[];
+    issues: DriftIssue[];
+}
+interface AuditCommandOptions {
+    schema?: string;
+    json?: boolean;
+    cwd?: string;
+    stdout?: {
+        write: (message: string) => unknown;
+    };
+    stderr?: {
+        write: (message: string) => unknown;
+    };
+}
+declare function runAuditCommand(options?: AuditCommandOptions): Promise<AuditCommandResult>;
+
+type ExitCode$5 = 0 | 1;
+interface CheckCommandOptions {
+    target: EnvTarget;
+    schema?: string;
+    app?: string;
+    allowUnknown?: boolean;
+    json?: boolean;
+    strict?: boolean;
+    cwd?: string;
+    values?: Record<string, string | undefined>;
+    prefixPolicy?: PrefixPolicy;
+    now?: Date;
+    stdout?: {
+        write: (message: string) => unknown;
+    };
+    stderr?: {
+        write: (message: string) => unknown;
+    };
+}
+interface CheckCommandResult {
+    ok: boolean;
+    exitCode: ExitCode$5;
+    target: EnvTarget;
+    allowUnknown: boolean;
+    strict: boolean;
+    schemaPath: string;
+    summary: {
+        total: number;
+        errors: number;
+        warnings: number;
+    };
+    issues: EnvValidationIssue[];
+}
+declare function runCheckCommand(options: CheckCommandOptions): Promise<CheckCommandResult>;
+
+type ExitCode$4 = 0;
+type DeprecationStatus = "active" | "expired" | "no-deadline";
+interface DeprecationItem {
+    key: string;
+    scope: EnvScope;
+    replacedBy?: string;
+    removeAfter?: string;
+    message?: string;
+    status: DeprecationStatus;
+}
+interface DeprecationsCommandOptions {
+    schema?: string;
+    app?: string;
+    json?: boolean;
+    now?: Date;
+    cwd?: string;
+    stdout?: {
+        write: (message: string) => unknown;
+    };
+}
+interface DeprecationsCommandResult {
+    ok: true;
+    exitCode: ExitCode$4;
+    schemaPath: string;
+    app?: string;
+    count: number;
+    items: DeprecationItem[];
+}
+declare function runDeprecationsCommand(options?: DeprecationsCommandOptions): Promise<DeprecationsCommandResult>;
+
+type DotenvQuoteStyle = "none" | "single" | "double";
+interface DotenvBlankLine {
+    type: "blank";
+    raw: string;
+}
+interface DotenvCommentLine {
+    type: "comment";
+    raw: string;
+}
+interface DotenvPairLine {
+    type: "pair";
+    raw: string;
+    key: string;
+    value: string;
+    quote: DotenvQuoteStyle;
+    exported: boolean;
+    inlineComment?: string;
+}
+interface DotenvUnknownLine {
+    type: "unknown";
+    raw: string;
+}
+type DotenvLine = DotenvBlankLine | DotenvCommentLine | DotenvPairLine | DotenvUnknownLine;
+interface DotenvDocument {
+    lines: DotenvLine[];
+    newline: "\n" | "\r\n";
+    hasTrailingNewline: boolean;
+}
+declare function parseDotenv(content: string): DotenvDocument;
+declare function formatDotenvValue(value: string, preferredQuote?: DotenvQuoteStyle): string;
+interface WriteDotenvOptions {
+    updates?: Record<string, string | undefined>;
+    sortNewKeys?: boolean;
+}
+declare function writeDotenv(document: DotenvDocument, options?: WriteDotenvOptions): string;
+declare function dotenvToObject(document: DotenvDocument): Record<string, string>;
+
+type ExportFormat = "docker-compose" | "k8s" | "github-actions";
+type ExitCode$3 = 0 | 1;
+interface ExportCommandOptions {
+    format: ExportFormat;
+    schema?: string;
+    withValues?: boolean;
+    from?: string;
+    cwd?: string;
+    stdout?: {
+        write: (message: string) => unknown;
+    };
+    stderr?: {
+        write: (message: string) => unknown;
+    };
+}
+interface ExportCommandResult {
+    ok: boolean;
+    exitCode: ExitCode$3;
+    format: ExportFormat;
+    schemaPath?: string;
+    sourcePath?: string;
+    output?: string;
+}
+interface BuildExportOptions {
+    withValues: boolean;
+    sourceValues: Record<string, string | undefined>;
+}
+declare function renderExport(schema: EnvSchema, format: ExportFormat, options: BuildExportOptions): string;
+declare function runExportCommand(options: ExportCommandOptions): Promise<ExportCommandResult>;
+
+interface GenerateArtifactsOptions {
+    app?: string;
+}
+interface GeneratedArtifacts {
+    envExample: string;
+    envDefaults: string;
+    envMarkdown: string;
+    envAuditJson: string;
+    envLocal: string;
+}
+declare function generateArtifacts(schema: EnvSchema, options?: GenerateArtifactsOptions): GeneratedArtifacts;
+declare function generateTargetEnvFile(schema: EnvSchema, target: EnvTarget, options?: GenerateArtifactsOptions): string;
+
+interface GenerateCommandOptions {
+    schema?: string;
+    app?: string;
+    writeLocal?: boolean;
+    writeTargetFiles?: boolean;
+    cwd?: string;
+    stdout?: {
+        write: (message: string) => unknown;
+    };
+}
+interface GenerateCommandResult {
+    schemaPath: string;
+    writtenFiles: string[];
+    artifacts: GeneratedArtifacts;
+}
+declare function runGenerateCommand(options?: GenerateCommandOptions): Promise<GenerateCommandResult>;
+
+type ExitCode$2 = 0 | 1;
+interface MigrateMakeCommandOptions {
+    name: string;
+    cwd?: string;
+    migrationsDir?: string;
+    now?: Date;
+    stdout?: {
+        write: (message: string) => unknown;
+    };
+    stderr?: {
+        write: (message: string) => unknown;
+    };
+}
+interface MigrateMakeCommandResult {
+    ok: boolean;
+    exitCode: ExitCode$2;
+    id?: string;
+    filePath?: string;
+    migrationsDir?: string;
+}
+interface MigrateCommandOptions {
+    cwd?: string;
+    migrationsDir?: string;
+    stateFile?: string;
+    generatedSchemaFile?: string;
+    now?: Date;
+    stdout?: {
+        write: (message: string) => unknown;
+    };
+    stderr?: {
+        write: (message: string) => unknown;
+    };
+}
+interface MigrateCommandResult {
+    ok: boolean;
+    exitCode: ExitCode$2;
+    migrationsDir?: string;
+    statePath?: string;
+    applied: string[];
+    changedFiles: string[];
+}
+interface MigrateStatusCommandOptions {
+    cwd?: string;
+    migrationsDir?: string;
+    stateFile?: string;
+    generatedSchemaFile?: string;
+    json?: boolean;
+    stdout?: {
+        write: (message: string) => unknown;
+    };
+    stderr?: {
+        write: (message: string) => unknown;
+    };
+}
+interface MigrateStatusCommandResult {
+    ok: boolean;
+    exitCode: ExitCode$2;
+    migrationsDir: string;
+    statePath: string;
+    schemaPath?: string;
+    error?: string;
+    summary: {
+        total: number;
+        applied: number;
+        pending: number;
+        changed: number;
+        missing: number;
+    };
+    entries: Array<{
+        id: string;
+        status: "applied" | "pending" | "changed" | "missing";
+        filePath?: string;
+        appliedAt?: string;
+        checksum?: string;
+        currentChecksum?: string;
+    }>;
+}
+interface MigrateRollbackCommandOptions {
+    steps: number;
+    cwd?: string;
+    migrationsDir?: string;
+    stateFile?: string;
+    generatedSchemaFile?: string;
+    stdout?: {
+        write: (message: string) => unknown;
+    };
+    stderr?: {
+        write: (message: string) => unknown;
+    };
+}
+interface SchemaBuildCommandOptions {
+    cwd?: string;
+    migrationsDir?: string;
+    stateFile?: string;
+    generatedSchemaFile?: string;
+    force?: boolean;
+    stdout?: {
+        write: (message: string) => unknown;
+    };
+    stderr?: {
+        write: (message: string) => unknown;
+    };
+}
+interface MigrateRollbackCommandResult {
+    ok: boolean;
+    exitCode: ExitCode$2;
+    migrationsDir?: string;
+    statePath?: string;
+    rolledBack: string[];
+    changedFiles: string[];
+    remainingApplied?: number;
+}
+interface SchemaBuildCommandResult {
+    ok: boolean;
+    exitCode: ExitCode$2;
+    schemaPath?: string;
+    appliedMigrationIds?: string[];
+}
+declare function runMigrateMakeCommand(options: MigrateMakeCommandOptions): Promise<MigrateMakeCommandResult>;
+declare function runMigrateCommand(options?: MigrateCommandOptions): Promise<MigrateCommandResult>;
+declare function runMigrateStatusCommand(options?: MigrateStatusCommandOptions): Promise<MigrateStatusCommandResult>;
+declare function runMigrateRollbackCommand(options: MigrateRollbackCommandOptions): Promise<MigrateRollbackCommandResult>;
+declare function runSchemaBuildCommand(options?: SchemaBuildCommandOptions): Promise<SchemaBuildCommandResult>;
+
+declare const DEFAULT_MIGRATIONS_DIR = "env/migrations";
+declare const DEFAULT_MIGRATION_STATE_FILE = "env/migrations.state.json";
+declare const DEFAULT_GENERATED_SCHEMA_FILE = "env/schema.generated.json";
+declare const DEFAULT_MIGRATION_TARGET_FILES: readonly [".env.local", ".env", ".env.example", ".env.defaults"];
+type EnvMigrationTargetFile = (typeof DEFAULT_MIGRATION_TARGET_FILES)[number];
+interface EnvMigrationTargetOptions {
+    targets?: readonly EnvMigrationTargetFile[];
+}
+interface EnvMigrationUpdateVariableOptions extends EnvMigrationTargetOptions {
+    overwrite?: boolean;
+    createIfMissing?: boolean;
+    comment?: string | readonly string[];
+}
+interface EnvMigrationRemoveVariableOptions extends EnvMigrationTargetOptions {
+}
+interface EnvMigrationRenameVariableOptions extends EnvMigrationTargetOptions {
+    overwrite?: boolean;
+    comment?: string | readonly string[];
+}
+interface EnvMigrationVariableChain {
+    kind(kind: EnvVariableDefinition["kind"]): EnvMigrationVariableChain;
+    define(definition: EnvVariableDefinition): EnvMigrationVariableChain;
+    string(): EnvMigrationVariableChain;
+    url(): EnvMigrationVariableChain;
+    number(): EnvMigrationVariableChain;
+    boolean(): EnvMigrationVariableChain;
+    enum(): EnvMigrationVariableChain;
+    json(): EnvMigrationVariableChain;
+    scope(scope: "server" | "client"): EnvMigrationVariableChain;
+    requiredIn(targets: EnvTarget | readonly EnvTarget[]): EnvMigrationVariableChain;
+    defaultValue(value: unknown): EnvMigrationVariableChain;
+    sensitive(value?: boolean): EnvMigrationVariableChain;
+    values(values: string | readonly string[]): EnvMigrationVariableChain;
+    description(value: string | undefined): EnvMigrationVariableChain;
+    example(value: string | undefined): EnvMigrationVariableChain;
+    owner(value: string | undefined): EnvMigrationVariableChain;
+    rotationDays(value: number | undefined): EnvMigrationVariableChain;
+    deprecated(value: DeprecatedMetadata | undefined): EnvMigrationVariableChain;
+    deprecate(replacedBy?: string, removeAfter?: string, message?: string): EnvMigrationVariableChain;
+    provider(value: ProviderMapping | undefined): EnvMigrationVariableChain;
+    providerAlias(provider: string, key: string | undefined): EnvMigrationVariableChain;
+    tags(values: string | readonly string[] | undefined): EnvMigrationVariableChain;
+    tag(value: string): EnvMigrationVariableChain;
+    value(value: string): EnvMigrationVariableChain;
+    targets(targets: EnvMigrationTargetFile | readonly EnvMigrationTargetFile[]): EnvMigrationVariableChain;
+    overwrite(value?: boolean): EnvMigrationVariableChain;
+    createIfMissing(value?: boolean): EnvMigrationVariableChain;
+    comment(comment: string | readonly string[] | undefined): EnvMigrationVariableChain;
+    rename(toKey: string, options?: EnvMigrationRenameVariableOptions): EnvMigrationVariableChain;
+    remove(options?: EnvMigrationRemoveVariableOptions): EnvMigrationVariableChain;
+}
+interface MigrationDerivedSchema {
+    schemaPath: string;
+    schema: EnvSchema;
+    prefixPolicy?: PrefixPolicy;
+    appliedMigrationIds: string[];
+}
+interface EnvMigrationOperation {
+    kind: "updateVariable" | "removeVariable" | "renameVariable" | "setPrefixPolicy";
+    key?: string;
+    fromKey?: string;
+    toKey?: string;
+    targets: EnvMigrationTargetFile[];
+}
+interface EnvMigrationContext {
+    key(key: string): EnvMigrationVariableChain;
+    string(key: string): EnvMigrationVariableChain;
+    url(key: string): EnvMigrationVariableChain;
+    number(key: string): EnvMigrationVariableChain;
+    boolean(key: string): EnvMigrationVariableChain;
+    enum(key: string): EnvMigrationVariableChain;
+    json(key: string): EnvMigrationVariableChain;
+    setPrefixPolicy(policy: PrefixPolicy | "nextjs" | "vite" | undefined): void;
+}
+interface EnvMigrationModule {
+    id: string;
+    up(ctx: EnvMigrationContext): Promise<void> | void;
+    down(ctx: EnvMigrationContext): Promise<void> | void;
+}
+interface LoadedEnvMigration extends EnvMigrationModule {
+    filePath: string;
+    checksum: string;
+}
+interface AppliedMigrationState {
+    id: string;
+    appliedAt: string;
+    checksum: string;
+}
+interface EnvMigrationState {
+    version: 1;
+    applied: AppliedMigrationState[];
+}
+interface MigrationStateLoadResult {
+    statePath: string;
+    state: EnvMigrationState;
+}
+interface MigrationStatusEntry {
+    id: string;
+    status: "applied" | "pending" | "changed" | "missing";
+    filePath?: string;
+    appliedAt?: string;
+    checksum?: string;
+    currentChecksum?: string;
+}
+interface MigrationStatusResult {
+    migrationsDir: string;
+    statePath: string;
+    entries: MigrationStatusEntry[];
+    summary: {
+        total: number;
+        applied: number;
+        pending: number;
+        changed: number;
+        missing: number;
+    };
+}
+interface ApplyMigrationsOptions {
+    cwd?: string;
+    migrationsDir?: string;
+    stateFile?: string;
+    generatedSchemaFile?: string;
+    now?: Date;
+}
+interface ApplyMigrationsResult {
+    migrationsDir: string;
+    statePath: string;
+    applied: string[];
+    changedFiles: string[];
+    pendingCount: number;
+}
+interface RollbackMigrationsOptions extends ApplyMigrationsOptions {
+    steps: number;
+}
+interface RollbackMigrationsResult {
+    migrationsDir: string;
+    statePath: string;
+    rolledBack: string[];
+    changedFiles: string[];
+    remainingApplied: number;
+}
+interface CreateMigrationFileOptions {
+    name: string;
+    cwd?: string;
+    migrationsDir?: string;
+    now?: Date;
+    template?: (id: string) => string;
+}
+interface CreateMigrationFileResult {
+    id: string;
+    filePath: string;
+    migrationsDir: string;
+}
+interface LoadedEnvTargetDocument {
+    target: EnvMigrationTargetFile;
+    filePath: string;
+    document: DotenvDocument;
+    source: string;
+}
+type LoadedEnvTargetDocuments = Map<EnvMigrationTargetFile, LoadedEnvTargetDocument>;
+interface InMemorySchemaState {
+    schema: EnvSchema;
+    prefixPolicy?: PrefixPolicy;
+}
+declare function loadEnvTargetDocuments(options?: {
+    cwd?: string;
+    targets?: readonly EnvMigrationTargetFile[];
+}): Promise<LoadedEnvTargetDocuments>;
+declare function hasKeyInTargetDocuments(documents: LoadedEnvTargetDocuments, target: EnvMigrationTargetFile, key: string): boolean;
+declare function finalizeFluentDefinitions(context: EnvMigrationContext): void;
+declare function createEnvMigrationContext(documents: LoadedEnvTargetDocuments, operationLog?: EnvMigrationOperation[], schemaState?: InMemorySchemaState): EnvMigrationContext;
+declare function writeEnvTargetDocuments(documents: LoadedEnvTargetDocuments): Promise<string[]>;
+declare function loadMigrationState(options?: {
+    cwd?: string;
+    stateFile?: string;
+}): Promise<MigrationStateLoadResult>;
+declare function saveMigrationState(cwd: string, statePath: string, state: EnvMigrationState): Promise<void>;
+declare function discoverMigrations(options?: {
+    cwd?: string;
+    migrationsDir?: string;
+}): Promise<{
+    migrationsDir: string;
+    migrations: LoadedEnvMigration[];
+}>;
+declare function getMigrationStatus(options?: {
+    cwd?: string;
+    migrationsDir?: string;
+    stateFile?: string;
+}): Promise<MigrationStatusResult>;
+declare function loadOrBuildMigrationSchema(options?: {
+    cwd?: string;
+    migrationsDir?: string;
+    stateFile?: string;
+    generatedSchemaFile?: string;
+    forceRebuild?: boolean;
+    allowEmpty?: boolean;
+}): Promise<MigrationDerivedSchema>;
+declare function createMigrationFile(options: CreateMigrationFileOptions): Promise<CreateMigrationFileResult>;
+declare function applyPendingMigrations(options?: ApplyMigrationsOptions): Promise<ApplyMigrationsResult>;
+declare function rollbackMigrations(options: RollbackMigrationsOptions): Promise<RollbackMigrationsResult>;
+
+type ProviderName = "vercel" | "heroku";
+type ExitCode$1 = 0 | 1;
+interface CommandRunnerOptions {
+    cwd?: string;
+}
+interface CommandRunnerResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    missingBinary: boolean;
+}
+type CommandRunner = (command: string, args: readonly string[], options?: CommandRunnerOptions) => Promise<CommandRunnerResult>;
+declare function runExternalCommand(command: string, args: readonly string[], options?: CommandRunnerOptions): Promise<CommandRunnerResult>;
+interface DoctorCheck {
+    name: string;
+    ok: boolean;
+    message: string;
+    fix?: string;
+}
+interface DoctorResult {
+    ok: boolean;
+    exitCode: ExitCode$1;
+    schemaPath?: string;
+    checks: DoctorCheck[];
+}
+interface DoctorCommandOptions {
+    schema?: string;
+    cwd?: string;
+    runner?: CommandRunner;
+    stdout?: {
+        write: (message: string) => unknown;
+    };
+    stderr?: {
+        write: (message: string) => unknown;
+    };
+}
+declare function runDoctorCommand(options?: DoctorCommandOptions): Promise<DoctorResult>;
+interface PullVercelOptions {
+    env: EnvTarget;
+    cwd?: string;
+    runner?: CommandRunner;
+    stdout?: {
+        write: (message: string) => unknown;
+    };
+    stderr?: {
+        write: (message: string) => unknown;
+    };
+}
+interface PullVercelResult {
+    ok: boolean;
+    exitCode: ExitCode$1;
+    outputPath: string;
+}
+declare function runPullVercelCommand(options: PullVercelOptions): Promise<PullVercelResult>;
+interface DiffCommandOptions {
+    provider: ProviderName;
+    env?: EnvTarget;
+    app?: string;
+    target?: EnvTarget;
+    schema?: string;
+    snapshot?: string;
+    allowUnknown?: boolean;
+    json?: boolean;
+    cwd?: string;
+    stdout?: {
+        write: (message: string) => unknown;
+    };
+    stderr?: {
+        write: (message: string) => unknown;
+    };
+}
+interface DiffCommandResult {
+    provider: ProviderName;
+    ok: boolean;
+    exitCode: ExitCode$1;
+    schemaPath: string;
+    snapshotPath: string;
+    target: EnvTarget;
+    summary: {
+        total: number;
+        errors: number;
+        warnings: number;
+    };
+    issues: DriftIssue[];
+}
+declare function runDiffCommand(options: DiffCommandOptions): Promise<DiffCommandResult>;
+interface PushHerokuOptions {
+    app: string;
+    target: EnvTarget;
+    from: string;
+    schema?: string;
+    cwd?: string;
+    runner?: CommandRunner;
+    stdout?: {
+        write: (message: string) => unknown;
+    };
+    stderr?: {
+        write: (message: string) => unknown;
+    };
+}
+interface PushHerokuResult {
+    ok: boolean;
+    exitCode: ExitCode$1;
+    pushedKeys: string[];
+    skippedKeys: string[];
+}
+declare function runPushHerokuCommand(options: PushHerokuOptions): Promise<PushHerokuResult>;
+
+type ExitCode = 0 | 1;
+interface ReconcileCommandOptions {
+    schema?: string;
+    app?: string;
+    cwd?: string;
+    writeMigration?: boolean;
+    migrationsDir?: string;
+    now?: Date;
+    stdout?: {
+        write: (message: string) => unknown;
+    };
+    stderr?: {
+        write: (message: string) => unknown;
+    };
+}
+interface ReconcileAddedKey {
+    key: string;
+    definition: EnvVariableDefinition;
+    value: string;
+    targets: EnvMigrationTargetFile[];
+}
+interface ReconcileCommandResult {
+    ok: boolean;
+    exitCode: ExitCode;
+    schemaPath?: string;
+    changedFiles: string[];
+    added: ReconcileAddedKey[];
+    migrationId?: string;
+    migrationPath?: string;
+}
+declare function runReconcileCommand(options?: ReconcileCommandOptions): Promise<ReconcileCommandResult>;
+
+declare const DEFAULT_SCHEMA_FILES: readonly ["env.schema.mjs", "env.schema.js", "env.schema.cjs", "env.schema.json"];
+interface LoadedSchema {
+    schema: EnvSchema;
+    prefixPolicy?: PrefixPolicy;
+    schemaPath: string;
+    app?: string;
+}
+interface LoadSchemaOptions {
+    app?: string;
+}
+interface ResolveSchemaPathOptions {
+    migrationsDir?: string;
+    stateFile?: string;
+    generatedSchemaFile?: string;
+    forceRebuildMigrationSchema?: boolean;
+}
+declare function resolveSchemaPath(schemaPath: string | undefined, cwd: string, options?: ResolveSchemaPathOptions): Promise<string>;
+declare function loadSchema(schemaPath: string, options?: LoadSchemaOptions): Promise<LoadedSchema>;
+
+export { type AppliedMigrationState, type ApplyMigrationsOptions, type ApplyMigrationsResult, type AuditCommandOptions, type AuditCommandResult, type AuditTargetResult, type CheckCommandOptions, type CheckCommandResult, type CommandRunner, type CommandRunnerOptions, type CommandRunnerResult, type CreateMigrationFileOptions, type CreateMigrationFileResult, DEFAULT_GENERATED_SCHEMA_FILE, DEFAULT_MIGRATIONS_DIR, DEFAULT_MIGRATION_STATE_FILE, DEFAULT_MIGRATION_TARGET_FILES, DEFAULT_SCHEMA_FILES, DeprecatedMetadata, type DeprecationItem, type DeprecationsCommandOptions, type DeprecationsCommandResult, type DiffCommandOptions, type DiffCommandResult, type DoctorCheck, type DoctorCommandOptions, type DoctorResult, type DotenvBlankLine, type DotenvCommentLine, type DotenvDocument, type DotenvLine, type DotenvPairLine, type DotenvQuoteStyle, type DotenvUnknownLine, type DriftIssue, type DriftOptions, type DriftResult, type DriftSummary, type EnvMigrationContext, type EnvMigrationModule, type EnvMigrationOperation, type EnvMigrationRemoveVariableOptions, type EnvMigrationRenameVariableOptions, type EnvMigrationState, type EnvMigrationTargetFile, type EnvMigrationTargetOptions, type EnvMigrationUpdateVariableOptions, type EnvMigrationVariableChain, EnvSchema, EnvScope, EnvTarget, EnvValidationIssue, EnvVariableDefinition, type ExportCommandOptions, type ExportCommandResult, type ExportFormat, type GenerateArtifactsOptions, type GenerateCommandOptions, type GenerateCommandResult, type GeneratedArtifacts, type LoadSchemaOptions, type LoadedEnvMigration, type LoadedEnvTargetDocument, type LoadedEnvTargetDocuments, type LoadedSchema, type MigrateCommandOptions, type MigrateCommandResult, type MigrateMakeCommandOptions, type MigrateMakeCommandResult, type MigrateRollbackCommandOptions, type MigrateRollbackCommandResult, type MigrateStatusCommandOptions, type MigrateStatusCommandResult, type MigrationDerivedSchema, type MigrationStateLoadResult, type MigrationStatusEntry, type MigrationStatusResult, PrefixPolicy, ProviderMapping, type ProviderName, type PullVercelOptions, type PullVercelResult, type PushHerokuOptions, type PushHerokuResult, type ReconcileAddedKey, type ReconcileCommandOptions, type ReconcileCommandResult, type ResolveSchemaPathOptions, type RollbackMigrationsOptions, type RollbackMigrationsResult, type SchemaBuildCommandOptions, type SchemaBuildCommandResult, type WriteDotenvOptions, applyPendingMigrations, createEnvMigrationContext, createMigrationFile, detectDrift, discoverMigrations, dotenvToObject, finalizeFluentDefinitions, formatDotenvValue, generateArtifacts, generateTargetEnvFile, getMigrationStatus, hasKeyInTargetDocuments, loadEnvTargetDocuments, loadMigrationState, loadOrBuildMigrationSchema, loadSchema, parseDotenv, renderExport, resolveSchemaPath, rollbackMigrations, runAuditCommand, runCheckCommand, runDeprecationsCommand, runDiffCommand, runDoctorCommand, runExportCommand, runExternalCommand, runGenerateCommand, runMigrateCommand, runMigrateMakeCommand, runMigrateRollbackCommand, runMigrateStatusCommand, runPullVercelCommand, runPushHerokuCommand, runReconcileCommand, runSchemaBuildCommand, saveMigrationState, writeDotenv, writeEnvTargetDocuments };