import * as MO from "../_schema.js";
import * as Arbitrary from "../Arbitrary.js";
import * as Constructor from "../Constructor.js";
import * as Encoder from "../Encoder.js";
import * as Guard from "../Guard.js";
import * as Parser from "../Parser.js";
import * as S from "./schemed.js";
export type SchemaForModel<M, Self extends MO.SchemaAny> = MO.Schema<MO.ParserInputOf<Self>, M, MO.ConstructorInputOf<Self>, MO.EncodedOf<Self>, MO.ApiOf<Self> & MO.ApiSelfType<M>>;
export type ParserFor<Self extends MO.SchemaAny> = Parser.Parser<MO.ParserInputOf<Self>, MO.ParserErrorOf<Self>, MO.ParsedShapeOf<Self>>;
export type ConstructorFor<Self extends MO.SchemaAny> = Constructor.Constructor<MO.ConstructorInputOf<Self>, MO.ParsedShapeOf<Self>, MO.ConstructorErrorOf<Self>>;
export type EncoderFor<Self extends MO.SchemaAny> = Encoder.Encoder<MO.ParsedShapeOf<Self>, MO.EncodedOf<Self>>;
export type GuardFor<Self extends MO.SchemaAny> = Guard.Guard<MO.ParsedShapeOf<Self>>;
export type ArbitraryFor<Self extends MO.SchemaAny> = Arbitrary.Gen<MO.ParsedShapeOf<Self>>;
export type ModelFor<M, Self extends MO.SchemaAny> = M extends MO.ParsedShapeOf<Self> ? SchemaForModel<M, Self> : SchemaForModel<MO.ParsedShapeOf<Self>, Self>;
export interface Model<M, Self extends MO.SchemaAny> extends S.Schemed<Self>, MO.Schema<MO.ParserInputOf<Self>, M, MO.ConstructorInputOf<Self>, MO.EncodedOf<Self>, MO.ApiOf<Self>> {
    [S.schemaField]: Self;
    readonly Parser: ParserFor<SchemaForModel<M, Self>>;
    readonly Constructor: ConstructorFor<SchemaForModel<M, Self>>;
    readonly Encoder: EncoderFor<SchemaForModel<M, Self>>;
    readonly Guard: GuardFor<SchemaForModel<M, Self>>;
    readonly Arbitrary: ArbitraryFor<SchemaForModel<M, Self>>;
}
/**
 * @inject genericName
 */
export declare function Model<M>(__name?: string): <Self extends MO.SchemaAny>(self: Self) => Model<M, Self>;
//# sourceMappingURL=model.d.ts.map