@vaadin/hilla-models/converters.d.ts

Generative form models for Hilla

import { $assertSupportedModel, type $targetModel, type Constraint, type CompositeOf, type SourceModel, type TargetModel, type Model, type ModelConverter, type ModelMetadata, type Value } from './Model.js';
import { ArrayModel, type OptionalModel } from './models.js';
export type ModelConverterFn<SM extends Model = Model, TM extends Model = Model> = (model: SM, ...extraArgs: readonly any[]) => TM;
export type ModelConverterCallable<MC extends ModelConverter, F extends ModelConverterFn<SourceModel<MC>, TargetModel<MC, SourceModel<MC>>>> = F extends (model: Model, ...extraArgs: infer E) => Model ? <const IMC extends ModelConverter>(modelConverter: IMC, ...extraArgs: E) => CompositeOf<MC, IMC> : never;
export interface IdentityOf extends ModelConverter {
    readonly [$targetModel]: SourceModel<this>;
}
declare function selfImpl<const M extends Model>(model: M): M;
export type ModelSelf = IdentityOf & typeof selfImpl;
declare const _self: ModelSelf;
export { _self as self };
export interface OptionalOf extends ModelConverter {
    readonly [$targetModel]: OptionalModel<SourceModel<this>>;
}
declare function optionalImpl<const M extends Model>(model: M): OptionalModel<M>;
export declare const optional: OptionalOf & typeof optionalImpl & (<const IMC extends ModelConverter>(modelConverter: IMC) => CompositeOf<OptionalOf, IMC>);
export interface ArrayOf extends ModelConverter {
    readonly [$targetModel]: ArrayModel<SourceModel<this>>;
}
declare function arrayImpl<const M extends Model>(model: M): ArrayModel<M>;
export declare const array: ArrayOf & typeof arrayImpl & (<const IMC extends ModelConverter>(modelConverter: IMC) => CompositeOf<ArrayOf, IMC>);
declare function constrainedImpl<const M extends Model>(this: void, model: M, constraint: Constraint<Value<M>>, ...moreConstraints: ReadonlyArray<Constraint<Value<M>>>): M;
export declare const constrained: IdentityOf & typeof constrainedImpl & (<const IMC extends ModelConverter>(modelConverter: IMC, constraint: Readonly<{
    attributes: Readonly<Record<never, never>>;
    name: string;
    [$assertSupportedModel](model: Model<unknown, Readonly<Record<never, never>>>): void;
}>, ...moreConstraints: Readonly<{
    attributes: Readonly<Record<never, never>>;
    name: string;
    [$assertSupportedModel](model: Model<unknown, Readonly<Record<never, never>>>): void;
}>[]) => CompositeOf<IdentityOf, IMC>);
declare function metaImpl<const M extends Model>(this: void, model: M, metadata: ModelMetadata): M;
export declare const meta: IdentityOf & typeof metaImpl & (<const IMC extends ModelConverter>(modelConverter: IMC, metadata: ModelMetadata) => CompositeOf<IdentityOf, IMC>);