import type { ComputeFlat } from "@effect-ts/core/Utils";
import * as Lens from "@effect-ts/monocle/Lens";
import type { EncSchemaForModel, EParserFor, FromPropertyRecord } from "./_api.js";
import * as MO from "./_schema.js";
import type { AnyProperty, EncodedOf, ParsedShapeOf, PropertyRecord } from "./custom.js";
export declare const nModelBrand: unique symbol;
export type StringRecord = Record<string, string>;
export type AnyRecord = Record<string, any>;
export type AnyRecordSchema = MO.Schema<unknown, any, any, AnyRecord, any>;
export interface Model<ParsedShape, Self extends MO.SchemaAny> extends Model2<ParsedShape, Self, EncSchemaForModel<ParsedShape, Self, MO.EncodedOf<Self>>, ComputeFlat<MO.ParsedShapeOf<Self>>> {
}
export interface Model3<ParsedShape, ParsedShape2, Self extends MO.SchemaAny> extends Model2<ParsedShape, Self, EncSchemaForModel<ParsedShape, Self, MO.EncodedOf<Self>>, ParsedShape2> {
}
export interface ModelEnc<ParsedShape, Self extends MO.SchemaAny, MEnc, ParsedShape2 = ComputeFlat<MO.ParsedShapeOf<Self>>> extends MM<Self, EncSchemaForModel<ParsedShape, Self, MEnc>, ParsedShape, MO.ConstructorInputOf<Self>, MEnc, GetApiProps<Self>, ParsedShape2> {
}
export interface ModelEnc3<ParsedShape, ParsedShape2, Self extends MO.SchemaAny, MEnc> extends MM<Self, EncSchemaForModel<ParsedShape, Self, MEnc>, ParsedShape, MO.ConstructorInputOf<Self>, MEnc, GetApiProps<Self>, ParsedShape2> {
}
export interface Model2<M, Self extends MO.SchemaAny, SelfM extends MO.SchemaAny, ParsedShape2> extends MM<Self, SelfM, M, MO.ConstructorInputOf<Self>, MO.EncodedOf<Self>, GetApiProps<Self>, ParsedShape2> {
}
type GetApiProps<T extends MO.SchemaAny> = T extends MO.SchemaProperties<infer Props> ? Props : never;
export interface MNModel<Self extends MO.SchemaAny, ParsedShape = MO.ParsedShapeOf<Self>, ConstructorInput = MO.ConstructorInputOf<Self>, Encoded = MO.EncodedOf<Self>, Props = GetApiProps<Self>> extends MM<Self, MO.Schema<unknown, ParsedShape, ConstructorInput, Encoded, {
    props: Props;
}>, ParsedShape, ConstructorInput, Encoded, Props, ComputeFlat<MO.ParsedShapeOf<Self>>> {
}
export interface MM<Self extends MO.SchemaAny, SelfM extends MO.SchemaAny, ParsedShape, ConstructorInput, Encoded, Props, ParsedShape2> extends MO.Schema<unknown, ParsedShape, ConstructorInput, Encoded, {
    props: Props;
}> {
    new (_: ConstructorInput): ParsedShape2;
    [MO.schemaField]: Self;
    readonly parsed: ParsedShapeOf<Self>;
    readonly encoded: EncodedOf<Self>;
    readonly Model: SelfM;
    readonly lens: Lens.Lens<ParsedShape, ParsedShape>;
    readonly lenses: RecordSchemaToLenses<ParsedShape, Self>;
    readonly Parser: MO.ParserFor<SelfM>;
    readonly EParser: EParserFor<SelfM>;
    readonly Constructor: MO.ConstructorFor<SelfM>;
    readonly Encoder: MO.EncoderFor<SelfM>;
    readonly Guard: MO.GuardFor<SelfM>;
    readonly Arbitrary: MO.ArbitraryFor<SelfM>;
}
export declare function Model<ParsedShape>(__name?: string): <Props extends MO.PropertyRecord = {}>(props: Props) => Model<ParsedShape, MO.SchemaProperties<Props>> & PropsExtensions<Props extends MO.PropertyRecord ? Props : never>;
export declare function ModelEnc<ParsedShape, Encoded>(__name?: string): <Props extends MO.PropertyRecord = {}>(props: Props) => ModelEnc<ParsedShape, MO.SchemaProperties<Props>, Encoded, ComputeFlat<ComputeFlat<import("@effect-ts/system/Utils").UnionToIntersection<{ [k in keyof Props]: Props[k] extends MO.AnyProperty ? Props[k]["_optional"] extends "optional" ? { readonly [h in k]?: MO.ParsedShapeOf<Props[k]["_schema"]> | undefined; } : { readonly [h_1 in k]: MO.ParsedShapeOf<Props[k]["_schema"]>; } : never; }[keyof Props]>>>> & PropsExtensions<Props extends MO.PropertyRecord ? Props : never>;
export declare function Model3<ParsedShape, ParsedShape2>(__name?: string): <Props extends MO.PropertyRecord = {}>(props: Props) => Model3<ParsedShape, ParsedShape2, MO.SchemaProperties<Props>> & PropsExtensions<Props extends MO.PropertyRecord ? Props : never>;
export declare function Model4<ParsedShape>(__name?: string): <Props extends MO.PropertyRecord = {}>(props: Props) => Model3<ParsedShape, {}, MO.SchemaProperties<Props>> & PropsExtensions<Props extends MO.PropertyRecord ? Props : never>;
export declare function ModelEnc3<ParsedShape, ParsedShape2, Encoded>(__name?: string): <Props extends MO.PropertyRecord = {}>(props: Props) => ModelEnc3<ParsedShape, ParsedShape2, MO.SchemaProperties<Props>, Encoded> & PropsExtensions<Props extends MO.PropertyRecord ? Props : never>;
export declare function ModelEnc4<ParsedShape, Encoded>(__name?: string): <Props extends MO.PropertyRecord = {}>(props: Props) => ModelEnc3<ParsedShape, {}, MO.SchemaProperties<Props>, Encoded> & PropsExtensions<Props extends MO.PropertyRecord ? Props : never>;
export declare function MNModel<ParsedShape, ConstructorInput, Encoded, Props>(__name?: string): <ProvidedProps extends MO.PropertyRecord = {}>(props: ProvidedProps) => MNModel<MO.SchemaProperties<ProvidedProps>, ParsedShape, ConstructorInput, Encoded, Props> & PropsExtensions<Props>;
export declare function fromModel<ParsedShape>(__name?: string): <Props extends FromPropertyRecord = {}>(props: Props) => Model<ParsedShape, import("./_api.js").SchemaFromProperties<Props>> & PropsExtensions<Props extends MO.PropertyRecord ? Props : never>;
export type RecordSchemaToLenses<T, Self extends AnyRecordSchema> = {
    [K in keyof ParsedShapeOf<Self>]: Lens.Lens<T, ParsedShapeOf<Self>[K]>;
};
export type PropsToLenses<T, Props extends MO.PropertyRecord> = {
    [K in keyof Props]: Lens.Lens<T, MO.ParsedShapeOf<Props[K]["_schema"]>>;
};
export declare function lensFromProps<T>(): <Props extends MO.PropertyRecord>(props: Props) => PropsToLenses<T, Props>;
export declare function setSchema<Self extends MO.SchemaProperties<any>>(schemed: any, self: Self): void;
/**
 * Automatically assign the name of the Class to the MO.
 */
export declare function useClassNameForSchema(cls: any): any;
export type GetProps<Self> = Self extends {
    Api: {
        props: infer Props;
    };
} ? Props extends PropertyRecord ? Props : never : never;
export interface PropsExtensions<Props> {
    include: <NewProps extends Record<string, AnyProperty>>(fnc: (props: Props) => NewProps) => NewProps;
    pick: <P extends keyof Props>(...keys: readonly P[]) => Pick<Props, P>;
    omit: <P extends keyof Props>(...keys: readonly P[]) => Omit<Props, P>;
}
export declare function ModelSpecial<ParsedShape>(__name?: string): <Self extends MO.SchemaAny & {
    Api: {
        props: any;
    };
}>(self: Self) => Model<ParsedShape, Self> & PropsExtensions<GetProps<Self>>;
export declare function ModelSpecialEnc<ParsedShape, Encoded>(__name?: string): <Self extends MO.SchemaAny & {
    Api: {
        props: any;
    };
}>(self: Self) => ModelEnc<ParsedShape, Self, Encoded, ComputeFlat<MO.ParsedShapeOf<Self>>> & PropsExtensions<GetProps<Self>>;
export declare function ModelSpecial3<ParsedShape, ParsedShape2>(__name?: string): <Self extends MO.SchemaAny & {
    Api: {
        props: any;
    };
}>(self: Self) => Model3<ParsedShape, ParsedShape2, Self> & PropsExtensions<GetProps<Self>>;
export declare function ModelSpecialEnc3<ParsedShape, ParsedShape2, Encoded>(__name?: string): <Self extends MO.SchemaAny & {
    Api: {
        props: any;
    };
}>(self: Self) => ModelEnc3<ParsedShape, ParsedShape2, Self, Encoded> & PropsExtensions<GetProps<Self>>;
export {};
//# sourceMappingURL=Model.d.ts.map