jinaga/dist/specification/model.d.ts

Data management for web and mobile applications.

import { Match, Projection, Role, Specification } from "./specification";
type RoleMap = {
    [role: string]: string;
};
type PredecessorOf<T, R extends keyof T> = R extends any ? T[R] extends string ? never : T[R] extends number ? never : T[R] extends Date ? never : T[R] extends Date | string ? never : T[R] extends boolean ? never : R : never;
declare class FactOptions<T, TRoles extends keyof T> {
    factTypeByRole: RoleMap;
    constructor(factTypeByRole: RoleMap);
    predecessor<U extends TRoles>(role: U, predecessorConstructor: PredecessorConstructor<T[U]>): FactOptions<T, Exclude<TRoles, U>>;
}
type FactTypeMap = {
    [factType: string]: RoleMap;
};
type ExtractFactConstructors<T> = T extends [FactConstructor<infer First>, ...infer Rest] ? [First, ...ExtractFactConstructors<Rest>] : [];
export declare class ModelBuilder {
    readonly factTypeMap: FactTypeMap;
    constructor(factTypeMap?: FactTypeMap);
    type<T>(factConstructor: FactConstructor<T>, options?: (f: FactOptions<T, PredecessorOf<T, keyof T>>) => FactOptions<T, never>): ModelBuilder;
    with(types: (b: ModelBuilder) => ModelBuilder): ModelBuilder;
}
export declare function buildModel(types: (b: ModelBuilder) => ModelBuilder): Model;
export declare class Model {
    private readonly factTypeMap;
    constructor(factTypeMap?: FactTypeMap);
    given<T extends FactConstructor<unknown>[]>(...factConstructors: T): Given<ExtractFactConstructors<T>>;
}
export declare class SpecificationOf<T, U> {
    specification: Specification;
    constructor(specification: Specification);
    toDescriptiveString(depth: number): string;
}
export type ProjectionOf<TSpecification> = TSpecification extends SpecificationOf<unknown, infer TProjection> ? TProjection : never;
type MatchParameters<T> = T extends [infer First, ...infer Rest] ? [LabelOf<First>, ...MatchParameters<Rest>] : [FactRepository];
type SpecificationResult<U> = U extends LabelOf<infer V> ? V : U extends Traversal<infer V> ? Array<SpecificationResult<V>> : U extends object ? {
    [K in keyof U]: SpecificationResult<U[K]>;
} : U;
declare class Given<T extends any[]> {
    private factTypes;
    private factTypeMap;
    constructor(factTypes: string[], factTypeMap: FactTypeMap);
    match<U>(definition: (...parameters: MatchParameters<T>) => Traversal<U> | U): SpecificationOf<T, SpecificationResult<U>>;
    select<U>(selector: (...parameters: MatchParameters<T>) => U): SpecificationOf<T, SpecificationResult<U>>;
}
interface LabelMethods<T> {
    successors<U>(type: FactConstructor<U>, selector: (successor: LabelOf<U>) => LabelOf<T>): Traversal<LabelOf<U>>;
    predecessor(): Traversal<LabelOf<T>>;
}
export type LabelOf<T> = LabelMethods<T> & {
    [R in keyof T]: T[R] extends string ? string : T[R] extends number ? number : T[R] extends bigint ? bigint : T[R] extends Date ? string : T[R] extends Date | string ? string : T[R] extends boolean ? boolean : T[R] extends string | undefined ? string | undefined : T[R] extends number | undefined ? number | undefined : T[R] extends bigint | undefined ? bigint | undefined : T[R] extends Date | undefined ? string | undefined : T[R] extends Date | string | undefined ? string | undefined : T[R] extends Array<infer U> ? LabelOf<U> : T[R] extends infer U | undefined ? LabelOf<U> : LabelOf<T[R]>;
};
export declare class Traversal<T> {
    private input;
    matches: Match[];
    projection: Projection;
    constructor(input: T, matches: Match[], projection: Projection);
    join<U>(left: (input: T) => LabelOf<U>, right: LabelOf<U>): Traversal<T>;
    notExists<U>(tupleDefinition: (proxy: T) => Traversal<U>): Traversal<T>;
    exists<U>(tupleDefinition: (proxy: T) => Traversal<U>): Traversal<T>;
    private existentialCondition;
    private withCondition;
    select<U>(selector: (input: T) => U): Traversal<U>;
    selectMany<U>(selector: (input: T) => Traversal<U>): Traversal<U>;
}
export declare class FactRepository {
    private factTypeMap;
    constructor(factTypeMap: FactTypeMap);
    private unknownIndex;
    ofType<T>(factConstructor: FactConstructor<T>): Source<T>;
}
declare class Source<T> {
    private factRepository;
    private factTypeMap;
    private name;
    private factType;
    constructor(factRepository: FactRepository, factTypeMap: FactTypeMap, name: string, factType: string);
    join<U>(left: (input: LabelOf<T>) => LabelOf<U>, right: LabelOf<U>): Traversal<LabelOf<T>>;
}
export type FactConstructor<T> = (new (...args: any[]) => T) & {
    Type: string;
};
type PredecessorConstructor<T> = T extends Array<infer U> ? FactConstructor<U> : FactConstructor<T>;
interface LabelPayloadFact {
    type: "fact";
    root: string;
    path: Role[];
    factType: string;
}
interface LabelPayloadField {
    type: "field";
    root: string;
    fieldName: string;
}
interface LabelPayloadHash {
    type: "hash";
    root: string;
}
type LabelPayload = LabelPayloadFact | LabelPayloadField | LabelPayloadHash;
export declare function getPayload<T>(label: LabelOf<T>): LabelPayload;
export {};
//# sourceMappingURL=model.d.ts.map