/**
 * The schema contract the CLI sends alongside a locally-owned migration run.
 *
 * `engineVersion` is read from the schema engine this CLI actually bundles,
 * never hard-coded. The compiler compares it against its own constant and
 * rejects a mismatch outright (SCHEMA_ENGINE_VERSION_MISMATCH) — that check is
 * the guard that stops a CLI and compiler from lowering feature schema
 * differently while both believe they agree. Reading it from the loaded module
 * is what makes the guard real: hard-coding the string here would let the
 * bundle drift from the value we claim.
 */
export declare function resolveSchemaEngineVersion(): Promise<string>;
export interface SchemaHashInput {
    name: string;
    areaPath?: string[];
    schema?: {
        source?: string;
    } | undefined;
    tables?: unknown;
}
/**
 * Content hash of the migration-facing schema surface.
 *
 * Scope note: the compiler currently validates that this is a non-empty string
 * and echoes it back on `meta.schema` — it does not yet re-derive and compare
 * it (plan 001 leaves canonical re-derivation to the shared engine's hash API,
 * which has not landed). So this is not yet a security boundary, and must not
 * be relied on as one.
 *
 * It is still computed honestly rather than stubbed, for two reasons: the value
 * becomes load-bearing the moment that API lands, and a stable hash today gives
 * the compile response something meaningful to key on. Inputs are sorted and
 * the digest covers only what can change generated schema — feature identity,
 * area placement, and authored schema source.
 */
export declare function computeSchemaHash(features: readonly SchemaHashInput[], config: {
    name?: string;
    providers?: {
        database?: {
            name?: string;
        };
    };
}): string;
//# sourceMappingURL=schema-contract.d.ts.map