export type JsonObject = Record<string, unknown>;
export declare const isJsonObject: (value: unknown) => value is JsonObject;
export interface ConversionChange {
    readonly conversion: string;
    readonly at: string;
    readonly detail?: string;
}
interface ConversionBase<Kind extends string> {
    readonly kind: Kind;
    readonly describe: string;
}
export interface RenameConversion<From extends string = string, To extends string = string> extends ConversionBase<"rename"> {
    readonly from: From;
    readonly to: To;
}
export interface DropConversion<Key extends string = string> extends ConversionBase<"drop"> {
    readonly key: Key;
}
export interface RetypeConversion<Key extends string = string, In = unknown, Out = unknown> extends ConversionBase<"retype"> {
    readonly key: Key;
    readonly guard: (value: unknown) => value is In;
    convert(value: In): Out;
}
export interface MapValueConversion<Key extends string = string, Mapping extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>> extends ConversionBase<"mapValue"> {
    readonly key: Key;
    readonly mapping: Mapping;
}
export interface PinDefaultConversion<Key extends string = string, Value = unknown> extends ConversionBase<"pinDefault"> {
    readonly key: Key;
    readonly value: Value;
}
export interface TransformConversion<In extends JsonObject = JsonObject, Out extends JsonObject = JsonObject> extends ConversionBase<"transform"> {
    readonly applies: (value: JsonObject) => value is In;
    convert(value: In): Out;
}
export interface FoldConversion<From extends string = string, Into extends string = string, Out = unknown> extends ConversionBase<"fold"> {
    readonly from: readonly From[];
    readonly into: Into;
    readonly applies: (value: JsonObject) => boolean;
    convert(fields: Readonly<Partial<Record<From, unknown>>>, whole: JsonObject): Out;
}
export interface RetireEntriesConversion<Retired = unknown> extends ConversionBase<"retireEntries"> {
    readonly isRetired: (entry: unknown) => entry is Retired;
}
export interface AtConversion<Path extends string = string, Inner = unknown> extends ConversionBase<"at"> {
    readonly path: Path;
    readonly inner: Inner;
}
export type Conversion = RenameConversion | DropConversion | RetypeConversion | MapValueConversion | PinDefaultConversion | TransformConversion | FoldConversion | RetireEntriesConversion | AtConversion<string, Conversion>;
export type Granularity = "object" | "entries" | "record";
export declare const rename: <const From extends string, const To extends string>(from: From, to: To) => RenameConversion<From, To>;
export declare const drop: <const Key extends string>(key: Key) => DropConversion<Key>;
export declare const retype: <const Key extends string, In, Out>(key: Key, guard: (value: unknown) => value is In, convert: (value: In) => Out, describe?: string) => RetypeConversion<Key, In, Out>;
export declare const mapValue: <const Key extends string, const Mapping extends Readonly<Record<string, unknown>>>(key: Key, mapping: Mapping) => MapValueConversion<Key, Mapping>;
export declare const pinDefault: <const Key extends string, const Value>(key: Key, value: Value) => PinDefaultConversion<Key, Value>;
export declare const transform: <In extends JsonObject, Out extends JsonObject>(describe: string, applies: (value: JsonObject) => value is In, convert: (value: In) => Out) => TransformConversion<In, Out>;
export declare const fold: <const From extends string, const Into extends string, Out>(describe: string, shape: {
    readonly from: readonly From[];
    readonly into: Into;
    readonly applies: (value: JsonObject) => boolean;
    readonly convert: (fields: Readonly<Partial<Record<From, unknown>>>, whole: JsonObject) => Out;
}) => FoldConversion<From, Into, Out>;
export declare const dropAll: <const Keys extends readonly string[]>(keys: Keys) => { readonly [I in keyof Keys]: DropConversion<Keys[I] & string>; };
type Nested<Path extends string, History extends readonly Conversion[], Entries extends boolean> = {
    readonly [I in keyof History]: History[I] extends RetireEntriesConversion ? AtConversion<Path, History[I]> : AtConversion<Entries extends true ? `${Path}.*` : Path, History[I]>;
};
export declare const nested: <const Path extends string, const History extends readonly Conversion[], const Entries extends boolean = false>(path: Path, history: History, entries?: Entries) => Nested<Path, History, Entries>;
export declare const retireEntries: <Retired>(describe: string, isRetired: (entry: unknown) => entry is Retired) => RetireEntriesConversion<Retired>;
export declare const at: <const Path extends string, const Inner extends Conversion>(path: Path, inner: Inner) => AtConversion<Path, Inner>;
export declare class ConversionError extends Error {
    readonly conversion: string;
    constructor(conversion: string, cause: unknown);
}
export interface Converted {
    readonly value: unknown;
    readonly changes: readonly ConversionChange[];
}
export declare const convertDocument: (conversions: readonly Conversion[], granularity: Granularity, raw: unknown, checkSettles?: boolean) => Converted;
export declare const describeConversions: (conversions: readonly Conversion[]) => string[];
export {};
//# sourceMappingURL=conversions.d.ts.map