@thisisagile/easy 15.8.4 → 15.8.6

package/dist/index.d.ts

@@ -1,12 +1,2821 @@
-export * from './data';
-export * from './domain';
-export * from './http';
-export * from './health';
-export * from './process';
-export * from './resources';
-export * from './services';
-export * from './security';
-export * from './sql';
-export * from './types';
-export * from './utils';
-export * from './validation';
+import { DateTimeUnit as DateTimeUnit$1, DateTime as DateTime$1 } from 'luxon';
+import { RequestHandler } from 'express';
+import { AxiosInstance } from 'axios';
+
+type OneOrMore<T> = T | Array<T>;
+type ArrayLike<T> = OneOrMore<T>[];
+declare const toArray: <T>(...items: ArrayLike<T>) => T[];
+declare const toObject: <T>(key: keyof T, ...items: ArrayLike<T>) => Record<string | number | symbol, T>;
+declare const array: {
+    merge: (first?: any[], second?: any[], firstKey?: string, secondKey?: string) => any[];
+    switch: <T>(items: T[] | undefined, item: T) => T[];
+    splitIn: <T_1>(items?: T_1[], length?: number) => T_1[][];
+};
+
+type Func$1<T, Args = unknown> = (...args: Args[]) => T;
+declare const isFunc: <T, Args>(o?: unknown) => o is (...params: Args[]) => T;
+
+type Get<T = any, Args = any> = Func$1<T, Args> | T;
+type Predicate<Args = unknown> = Get<boolean, Args>;
+declare const ofGet: <T, Args = any>(g: Get<T, Args>, ...args: Args[]) => T;
+declare const ifGet: <T>(pred: Get, valid: Get<T, any>, invalid: Get<T, any>) => T;
+type GetProperty<T, Prop> = keyof T | Func$1<Prop, T>;
+declare const ofProperty: <T, Prop>(t: T, p: GetProperty<T, Prop>) => Prop;
+
+type DontInfer<T> = [T][T extends any ? 0 : never];
+type Optional<T> = T | undefined;
+type PartialRecord<K extends keyof any, T> = {
+    [P in K]?: T;
+};
+
+type Constructor<T = unknown> = {
+    new (...args: any[]): T;
+};
+type Construct<Out, In = any> = Get<Out, In> | Constructor<Out>;
+declare const isConstructor: <T>(c?: unknown) => c is Constructor<T>;
+declare const ofConstruct: <T>(c: Construct<T, any>, ...args: unknown[]) => T;
+declare const toName: (subject?: unknown, postfix?: string) => string;
+declare const on: <T>(t: T, f: (t: T) => unknown) => T;
+declare const use: <T, Out>(t: T, f: (t: T) => Out) => Out;
+declare const ifA: <T>(c: Constructor<T>, t?: unknown, alt?: unknown) => Optional<T>;
+type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+}[Keys];
+
+declare const build: {
+    singleton: <T>(ctr: Constructor<T>, ...args: any[]) => T;
+    reset: () => void;
+};
+declare const singleton: <T>(ctr: Constructor<T>, ...args: any[]) => T;
+
+type CacheAge = `${number}${'ms' | 's' | 'm' | 'h' | 'd'}` | number;
+declare const cacheAge: {
+    toMilliseconds: (ca: CacheAge) => number;
+    toSeconds: (ca: CacheAge) => number;
+};
+
+interface Store<To = any, From = any> {
+    execute: (fetch: From, f: Func$1<Promise<To>, From>) => Promise<To>;
+}
+type CacheOptions = {
+    expiresIn?: CacheAge;
+    store?: Construct<Store>;
+};
+declare const toCacheOptions: (co: Partial<CacheOptions>) => CacheOptions;
+declare const cache: (options: Partial<CacheOptions>) => ClassDecorator;
+
+declare class CaseBuilder<V> {
+    readonly v: V;
+    constructor(v: V);
+    case<T>(pred: Predicate<V>, out: Get<T, V>): Case<T, V>;
+    type<T, U = unknown>(guard: TypeGuard<U>, out: Func$1<T, U>): Case<T, V>;
+    equals<T>(value: V, out: Get<T, V>): Case<T, V>;
+    is: {
+        defined: <T>(prop: Func$1<unknown, V>, out: Get<T, V>) => Case<T, V>;
+        empty: <T_1>(prop: Func$1<unknown, V>, out: Get<T_1, V>) => Case<T_1, V>;
+        valid: <T_2>(prop: Func$1<unknown, V>, out: Get<T_2, V>) => Case<T_2, V>;
+        not: {
+            defined: <T_3>(prop: Func$1<unknown, V>, out: Get<T_3, V>) => Case<T_3, V>;
+            empty: <T_4>(prop: Func$1<unknown, V>, out: Get<T_4, V>) => Case<T_4, V>;
+            valid: <T_5>(prop: Func$1<unknown, V>, out: Get<T_5, V>) => Case<T_5, V>;
+        };
+    };
+    if: {
+        defined: <T>(prop: Func$1<unknown, V>, out: Get<T, V>) => Case<T, V>;
+        empty: <T_1>(prop: Func$1<unknown, V>, out: Get<T_1, V>) => Case<T_1, V>;
+        valid: <T_2>(prop: Func$1<unknown, V>, out: Get<T_2, V>) => Case<T_2, V>;
+        not: {
+            defined: <T_3>(prop: Func$1<unknown, V>, out: Get<T_3, V>) => Case<T_3, V>;
+            empty: <T_4>(prop: Func$1<unknown, V>, out: Get<T_4, V>) => Case<T_4, V>;
+            valid: <T_5>(prop: Func$1<unknown, V>, out: Get<T_5, V>) => Case<T_5, V>;
+        };
+    };
+}
+declare class Case<T, V = unknown> {
+    protected value: V;
+    protected outcome?: T | undefined;
+    constructor(value: V, outcome?: T | undefined);
+    case(pred: Predicate<V>, out: Get<T, V>): Case<T, V>;
+    type<U>(guard: TypeGuard<U>, out: Func$1<T, U>): Case<T, V>;
+    equals(value: V, out: Get<T, V>): Case<T, V>;
+    is: {
+        defined: (prop: Func$1<unknown, V>, out: Get<T, V>) => Case<T, V>;
+        empty: (prop: Func$1<unknown, V>, out: Get<T, V>) => Case<T, V>;
+        valid: (prop: Func$1<unknown, V>, out: Get<T, V>) => Case<T, V>;
+        not: {
+            defined: (prop: Func$1<unknown, V>, out: Get<T, V>) => Case<T, V>;
+            empty: (prop: Func$1<unknown, V>, out: Get<T, V>) => Case<T, V>;
+            valid: (prop: Func$1<unknown, V>, out: Get<T, V>) => Case<T, V>;
+        };
+    };
+    if: {
+        defined: (prop: Func$1<unknown, V>, out: Get<T, V>) => Case<T, V>;
+        empty: (prop: Func$1<unknown, V>, out: Get<T, V>) => Case<T, V>;
+        valid: (prop: Func$1<unknown, V>, out: Get<T, V>) => Case<T, V>;
+        not: {
+            defined: (prop: Func$1<unknown, V>, out: Get<T, V>) => Case<T, V>;
+            empty: (prop: Func$1<unknown, V>, out: Get<T, V>) => Case<T, V>;
+            valid: (prop: Func$1<unknown, V>, out: Get<T, V>) => Case<T, V>;
+        };
+    };
+    else(alt: Get<T, V>): T;
+}
+declare const choose: <V>(value: V) => CaseBuilder<V>;
+
+type Uuid = string;
+declare const isUuid: (id?: unknown) => id is string;
+declare const toUuid: () => Uuid;
+
+type Id = string | number;
+type Key = Id;
+type Code = Id;
+type HasId = {
+    id: Id;
+};
+declare const toId: () => Id;
+
+type Identity = {
+    id: Id;
+    user?: string;
+};
+
+interface EnvContext {
+    readonly domain: string;
+    readonly name: string;
+    readonly host: string;
+    readonly port: number;
+    readonly app: string;
+    get(key: string, alt?: string): Optional<string>;
+}
+declare class DotEnvContext implements EnvContext {
+    readonly domain: string;
+    readonly name: string;
+    readonly host: string;
+    readonly port: number;
+    readonly app: string;
+    readonly get: (key: string, alt?: string) => Optional<string>;
+}
+interface RequestContext {
+    token?: any;
+    identity?: Identity;
+    jwt: string;
+    correlationId?: Uuid;
+    lastError?: string;
+    get<T>(key: string): T;
+    set<T>(key: string, value: T): T;
+    create: (f: () => void) => void;
+    wrap<T>(f: () => Promise<T>): Promise<T>;
+}
+declare class BaseRequestContext implements RequestContext {
+    private state;
+    get token(): any;
+    set token(token: any);
+    get identity(): Identity;
+    get jwt(): string;
+    set jwt(jwt: string);
+    get correlationId(): Uuid;
+    set correlationId(id: Uuid);
+    get lastError(): Optional<string>;
+    set lastError(error: Optional<string>);
+    get<T>(key: string): T;
+    set<T>(key: string, value: T): T;
+    readonly create: (f: () => void) => void;
+    readonly wrap: <T>(f: () => Promise<T>) => Promise<T>;
+}
+declare class BaseContext extends BaseRequestContext {
+}
+interface Contexts {
+    env?: EnvContext;
+    request?: RequestContext;
+    other?: any;
+}
+declare class Context {
+    protected state: Contexts;
+    constructor(state?: Contexts);
+    get env(): EnvContext;
+    set env(env: EnvContext);
+    get request(): RequestContext;
+    set request(request: RequestContext);
+    get other(): any;
+}
+declare const ctx: Context;
+
+type TypeGuard<T extends From, From = unknown> = (value?: From) => value is T;
+
+type JsonValue = string | number | boolean | null | Json | JsonValue[];
+type Json = {
+    [key: string]: JsonValue;
+};
+declare const isJson: TypeGuard<{
+    toJSON: () => Json;
+}>;
+declare const json: {
+    parse: <T extends Json = Json>(subject: unknown) => T;
+    merge: (...subjects: unknown[]) => Json;
+    delete: <T_1 extends Json = Json>(subject: T_1, key: string) => T_1;
+    set: <T_2 extends Json = Json>(subject: T_2, key?: string, value?: unknown) => T_2;
+    omit: <T_3 extends Json = Json>(subject: T_3, ...keys: string[]) => T_3;
+    defaults: <T_4 extends Json = Json>(options?: Partial<T_4>, defaults?: Partial<T_4>) => T_4;
+};
+declare const toJson: (...subjects: unknown[]) => Json;
+declare const asJson: (j?: unknown, alt?: Get<Json>) => Json;
+declare class Any<T extends Json> {
+    readonly value: T;
+    constructor(value: T);
+    merge: (...subjects: T[]) => Any<T>;
+    delete: (key: keyof T) => Any<T>;
+    omit: (...keys: (keyof T)[]) => Any<T>;
+    set: (key: keyof T, value?: unknown) => Any<T>;
+    toJSON(): Json;
+}
+declare const any: <T extends Json = Json>(value: T) => Any<T>;
+
+declare class List<T = unknown> extends Array<T> {
+    asc(p: GetProperty<T, any>): List<T>;
+    desc(p: GetProperty<T, any>): List<T>;
+    first(p?: (value: T, index: number, array: T[]) => unknown, params?: unknown): T;
+    firstValue<V>(f: (t: T) => V, alt?: Get<V, T>): Optional<V>;
+    isFirst(value: T): boolean;
+    next(p?: (value: T, index: number, array: T[]) => unknown, params?: unknown): T;
+    prev(p?: (value: T, index: number, array: T[]) => unknown, params?: unknown): T;
+    last(p?: (value: T, index: number, array: T[]) => unknown, params?: unknown): T;
+    isLast(value: T): boolean;
+    overlaps(...items: ArrayLike<T>): boolean;
+    diff(others: ArrayLike<T>): List<T>;
+    diffByKey(others: ArrayLike<T>, key: keyof T): List<T>;
+    intersect(others: ArrayLike<T>): List<T>;
+    intersectByKey(others: ArrayLike<T>, key: keyof T): List<T>;
+    toJSON(): Json[];
+    map<U>(f: (value: T, index: number, array: T[]) => U, params?: unknown): List<U>;
+    flatMap<U, This = unknown>(f: (this: This, value: T, index: number, array: T[]) => ReadonlyArray<U> | U, params?: This): List<U>;
+    mapDefined<U>(f: (value: T, index: number, array: T[]) => U, params?: unknown): List<NonNullable<U>>;
+    mapAsync(f: (i: T) => Promise<T>): Promise<List<T>>;
+    distinct(): List<T>;
+    distinctByKey(key: keyof T): List<T>;
+    filter(p: (value: T, index: number, array: T[]) => unknown, params?: unknown): List<T>;
+    sum(p: (t: T) => number): number;
+    byId(id: Id): T;
+    add(...items: ArrayLike<T>): this;
+    concat(...items: ConcatArray<T>[]): List<T>;
+    concat(...items: (T | ConcatArray<T>)[]): List<T>;
+    reverse(): List<T>;
+    splice(start: number, deleteCount?: number): List<T>;
+    splice(start: number, deleteCount: number, ...items: T[]): List<T>;
+    remove(item: T): List<T>;
+    replace(key: keyof T, item: T): List<T>;
+    switch(item: T): List<T>;
+    defined(): List<NonNullable<T>>;
+    toObject(key: keyof T, options?: {
+        deleteKey?: boolean;
+    }): Record<string | number | symbol, T>;
+    toObjectList(key: keyof T): Record<string | number | symbol, List<T>>;
+    orElse(...alt: ArrayLike<T>): Optional<List<T>>;
+    weave(insertFrom: T[], interval: number): this;
+    slice(start?: number, end?: number): List<T>;
+}
+declare const toList: <T = unknown>(...items: ArrayLike<T>) => List<T>;
+declare const isList: <T>(l?: unknown) => l is List<T>;
+declare const asList: <T>(c: Constructor<T>, items?: unknown | unknown[]) => List<T>;
+
+interface Validatable {
+    isValid: boolean;
+}
+declare const isValidatable: TypeGuard<Validatable>;
+
+declare abstract class Enum implements Validatable {
+    readonly name: string;
+    readonly id: Id;
+    readonly code: string;
+    protected constructor(name: string, id?: Id, code?: string);
+    get isValid(): boolean;
+    static all<E extends Enum>(): List<E>;
+    protected static allTuple<E extends Enum>(): Record<Id, E>;
+    static filter<E extends Enum>(p: (value: E, index: number, array: E[]) => unknown, params?: unknown): List<E>;
+    static first<E extends Enum>(p?: (value: E, index: number, array: E[]) => unknown, params?: unknown): E;
+    static byIds<E extends Enum>(ids?: Id[]): List<E>;
+    static byId<E extends Enum>(id: Id, alt?: Get<E, unknown>): E;
+    equals<E extends Enum>(other: E | Id): other is E;
+    isIn<E extends Enum>(...items: E[] | Id[]): boolean;
+    toJSON(): JsonValue;
+    toString(): string;
+}
+declare const isEnum: TypeGuard<Enum>;
+
+type Text = {
+    toString(): string;
+};
+declare const isText: (t?: unknown) => t is Text;
+declare const asString: (t?: unknown, alt?: Get<Text>) => string;
+declare const replaceAll: (origin: Text, search: Text, replace?: Text) => string;
+declare const kebab: (s?: string) => string;
+declare class ToText implements Text {
+    readonly subject: string;
+    constructor(subject: string);
+    get cap(): ToText;
+    get title(): ToText;
+    get pascal(): ToText;
+    get lower(): ToText;
+    get upper(): ToText;
+    get camel(): ToText;
+    get kebab(): ToText;
+    get strictKebab(): ToText;
+    get snake(): ToText;
+    get plural(): ToText;
+    get space(): ToText;
+    get sentence(): ToText;
+    get initials(): ToText;
+    get trim(): ToText;
+    get isEmpty(): boolean;
+    parse: (subject: unknown, options?: {}) => ToText;
+    is: (...others: unknown[]) => boolean;
+    equals: (...others: unknown[]) => boolean;
+    isLike: (...others: unknown[]) => boolean;
+    ifLike: (...others: unknown[]) => Optional<this>;
+    endsWith: (end?: unknown) => boolean;
+    startsWith: (end?: unknown) => boolean;
+    first: (n: number) => ToText;
+    last: (n: number) => ToText;
+    map: (func: Get<string, string>) => ToText;
+    replace: (search: Text, replace: Text) => ToText;
+    add: (add?: unknown, separator?: string) => ToText;
+    with: (separator: string, ...other: unknown[]) => ToText;
+    toString(): string;
+    toJSON(): JsonValue;
+}
+declare const text: (subject?: unknown, alt?: string) => ToText;
+
+declare class Exception extends Enum {
+    readonly message: string;
+    readonly reason?: Text | undefined;
+    static readonly AlreadyExists: Exception;
+    static readonly DoesNotExist: Exception;
+    static readonly IsMissingId: Exception;
+    static readonly IsNotImplemented: Exception;
+    static readonly IsNotValid: Exception;
+    static readonly Unknown: Exception;
+    constructor(message: string, id?: Id, reason?: Text | undefined);
+    static readonly CouldNotExecute: (target: Text) => Exception;
+    static readonly CouldNotValidate: (target: Text) => Exception;
+    static readonly EnvironmentVariableNotFound: (variable: Text) => Exception;
+    because: (reason: Text) => Exception;
+}
+declare const isException: (e?: unknown, t?: Text) => e is Exception;
+declare const isDoesNotExist: (e?: unknown) => e is Exception;
+
+declare class CacheControl {
+    readonly enabled: boolean;
+    private directives;
+    name: string;
+    protected constructor(enabled?: boolean, directives?: Record<string, boolean | CacheAge | undefined>);
+    static disabled: () => CacheControl;
+    static OneSecond: () => CacheControl;
+    static fiveSeconds: () => CacheControl;
+    static tenSeconds: () => CacheControl;
+    static thirtySeconds: () => CacheControl;
+    static sixtySeconds: () => CacheControl;
+    static custom: (maxAge?: CacheAge, staleWhileRevalidate?: CacheAge) => CacheControl;
+    readonly maxAge: (ca?: CacheAge) => this;
+    readonly sharedMaxAge: (ca?: CacheAge) => this;
+    readonly noCache: (a?: boolean) => this;
+    readonly mustRevalidate: (a?: boolean) => this;
+    readonly private: (a?: boolean) => this;
+    readonly public: (a?: boolean) => this;
+    readonly immutable: (a?: boolean) => this;
+    readonly staleWhileRevalidate: (ca?: CacheAge) => this;
+    value: () => string;
+    toString(): string;
+}
+
+declare class ContentType extends Enum {
+    readonly type: string;
+    protected readonly encoder: Get<string>;
+    static Form: ContentType;
+    static Json: ContentType;
+    static Stream: ContentType;
+    static Text: ContentType;
+    static Xml: ContentType;
+    private constructor();
+    encode: (body?: unknown) => string;
+}
+
+declare const HttpHeader: {
+    ContentType: string;
+    Correlation: string;
+};
+
+declare class HttpStatus extends Enum {
+    static Continue: HttpStatus;
+    static SwitchingProtocols: HttpStatus;
+    static Processing: HttpStatus;
+    static EarlyHints: HttpStatus;
+    static Ok: HttpStatus;
+    static Created: HttpStatus;
+    static Accepted: HttpStatus;
+    static NonAuthoritativeInformation: HttpStatus;
+    static NoContent: HttpStatus;
+    static ResetContent: HttpStatus;
+    static PartialContent: HttpStatus;
+    static MultiStatus: HttpStatus;
+    static AlreadyReported: HttpStatus;
+    static ImUsed: HttpStatus;
+    static MultipleChoices: HttpStatus;
+    static MovedPermanently: HttpStatus;
+    static Found: HttpStatus;
+    static SeeOther: HttpStatus;
+    static NotModified: HttpStatus;
+    static UseProxy: HttpStatus;
+    static SwitchProxy: HttpStatus;
+    static TemporaryRedirect: HttpStatus;
+    static PermanentRedirect: HttpStatus;
+    static BadRequest: HttpStatus;
+    static NotAuthorized: HttpStatus;
+    static PaymentRequired: HttpStatus;
+    static Forbidden: HttpStatus;
+    static NotFound: HttpStatus;
+    static MethodNotAllowed: HttpStatus;
+    static NotAcceptable: HttpStatus;
+    static ProxyAuthenticationRequired: HttpStatus;
+    static RequestTimeout: HttpStatus;
+    static Conflict: HttpStatus;
+    static Gone: HttpStatus;
+    static LengthRequired: HttpStatus;
+    static PreconditionFailed: HttpStatus;
+    static PayloadTooLarge: HttpStatus;
+    static UriTooLong: HttpStatus;
+    static UnsupportedMediaType: HttpStatus;
+    static RangeNotSatisfiable: HttpStatus;
+    static ExpectationFailed: HttpStatus;
+    static ImATeapot: HttpStatus;
+    static MisdirectedRequest: HttpStatus;
+    static UnprocessableEntity: HttpStatus;
+    static Locked: HttpStatus;
+    static FailedDependency: HttpStatus;
+    static TooEarly: HttpStatus;
+    static UpgradeRequired: HttpStatus;
+    static PreconditionRequired: HttpStatus;
+    static TooManyRequests: HttpStatus;
+    static RequestHeaderFieldsTooLarge: HttpStatus;
+    static UnavailableForLegalReasons: HttpStatus;
+    static InternalServerError: HttpStatus;
+    static NotImplemented: HttpStatus;
+    static BadGateway: HttpStatus;
+    static ServiceUnavailable: HttpStatus;
+    static GatewayTimeout: HttpStatus;
+    static HTTPVersionNotSupported: HttpStatus;
+    static VariantAlsoNegotiates: HttpStatus;
+    static InsufficientStorage: HttpStatus;
+    static LoopDetected: HttpStatus;
+    static NotExtended: HttpStatus;
+    static NetworkAuthenticationRequired: HttpStatus;
+    get isError(): boolean;
+    get isClientError(): boolean;
+    get isServerError(): boolean;
+    get status(): number;
+}
+declare const isHttpStatus: TypeGuard<HttpStatus>;
+declare const toHttpStatus: (s: HttpStatus | Code) => HttpStatus;
+
+declare class HttpVerb extends Enum {
+    static Get: HttpVerb;
+    static Put: HttpVerb;
+    static Patch: HttpVerb;
+    static Post: HttpVerb;
+    static Delete: HttpVerb;
+    constructor(name: string);
+}
+
+type VerbOptions = {
+    onOk?: HttpStatus;
+    onNotFound?: HttpStatus;
+    onError?: HttpStatus;
+    type?: ContentType;
+    cache?: CacheControl;
+};
+type Verb$1 = {
+    verb: HttpVerb;
+    options: VerbOptions;
+};
+declare const toVerbOptions: (options?: VerbOptions) => Required<VerbOptions>;
+declare const get: (options?: VerbOptions) => PropertyDecorator;
+declare const search: (options?: VerbOptions) => PropertyDecorator;
+declare const put: (options?: VerbOptions) => PropertyDecorator;
+declare const patch: (options?: VerbOptions) => PropertyDecorator;
+declare const post: (options?: VerbOptions) => PropertyDecorator;
+declare const del: (options?: VerbOptions) => PropertyDecorator;
+declare const stream: (options?: VerbOptions) => PropertyDecorator;
+
+declare class OriginatedError extends Error {
+    readonly origin: ErrorOrigin;
+    readonly options?: VerbOptions | undefined;
+    constructor(origin: ErrorOrigin, options?: VerbOptions | undefined);
+}
+declare const isOriginatedError: (e?: unknown) => e is OriginatedError;
+declare const toOriginatedError: (e: unknown, options?: VerbOptions) => OriginatedError;
+
+declare const toPageOptions: (options?: RequestOptions | PageOptions) => Optional<PageOptions>;
+declare class RequestOptions extends Enum {
+    readonly type: ContentType;
+    readonly headers: {
+        [key: string]: any;
+    };
+    pageOptions?: PageOptions | undefined;
+    requestOptions: {
+        maxRedirects?: number;
+        validateStatus?: (status: number) => boolean;
+        timeout?: CacheAge;
+    };
+    constructor(type?: ContentType, headers?: {
+        [key: string]: any;
+    }, pageOptions?: PageOptions | undefined);
+    static get Form(): RequestOptions;
+    static get Json(): RequestOptions;
+    static get Stream(): RequestOptions;
+    static get Text(): RequestOptions;
+    static get Xml(): RequestOptions;
+    page: (options: PageOptions) => this;
+    authorization: (auth: string) => this;
+    apiKey: (apiKey: string) => this;
+    setHeader: (key: Text, value: Id | boolean) => this;
+    setHeaderUnlessPresent: (key: string, value?: Id | boolean) => this;
+    accept: (type: ContentType) => this;
+    bearer: (jwt: Text) => this;
+    basic: (username: Text, password: Text) => this;
+    maxRedirects: (max?: number) => this;
+    validateStatus: (validate?: ((status: number) => boolean) | undefined) => this;
+    timeout: (t?: CacheAge) => this;
+}
+declare const isRequestOptions: (o?: unknown) => o is RequestOptions;
+
+type Request = {
+    uri: Uri;
+    verb: HttpVerb;
+    body?: unknown;
+    transform?: (r: any) => any;
+    transformError?: (r: any) => any;
+    options?: RequestOptions;
+};
+
+type RestResult = {
+    data?: {
+        code: number;
+        items: List<Json>;
+        itemCount: number;
+        totalItems?: number;
+        meta?: Json;
+    };
+    error?: {
+        code: number;
+        message: string;
+        errorCount: number;
+        errors: List<Result>;
+    };
+};
+declare const rest: {
+    toData: (status: HttpStatus, items?: Json[], totalItems?: number, meta?: Json) => RestResult;
+    toError: (status: HttpStatus, errors?: Result[]) => RestResult;
+    to: (payload?: any | any[], status?: HttpStatus) => RestResult;
+};
+declare const isRestResult: (r: unknown) => r is RestResult;
+
+type Response = {
+    status: HttpStatus;
+    headers?: {
+        [key: string]: any;
+    };
+    body: RestResult;
+};
+declare const isResponse: TypeGuard<Response>;
+declare const toResponse: (status: HttpStatus | Code, body?: unknown, headers?: {
+    [key: string]: any;
+} | undefined) => Response;
+
+interface RequestProvider {
+    execute: (request: Request) => Promise<Response>;
+}
+
+type Result = {
+    message: string;
+    location?: string;
+    domain?: string;
+};
+declare const toResult: (message: Text, location?: Text, domain?: Text) => Result;
+declare const isResult: TypeGuard<Result>;
+
+declare class Results implements Validatable {
+    readonly results: Result[];
+    constructor(...rs: (Text | Result)[]);
+    get length(): number;
+    get isValid(): boolean;
+    add: (...rs: (Text | Result)[]) => Results;
+}
+declare const toResults: (...r: (Text | Result)[]) => Results;
+declare const isResults: (r?: unknown) => r is Results;
+
+type ErrorOrigin = Text | Error | Exception | Response | Results | Result;
+
+type Falsy = false | 0 | -0 | 0n | '' | null | undefined;
+declare const isFalsy: (v?: unknown) => v is Falsy;
+declare const isTruthy: (v?: unknown) => v is unknown;
+
+declare const asc = 1;
+declare const desc = -1;
+type SortDirection = typeof asc | typeof desc;
+type Sort = {
+    key: string;
+    value: SortDirection;
+};
+type PlainSort = Record<string, SortDirection> | string[];
+
+type FilterValue = {
+    label?: string;
+    value: any;
+};
+type Filter = {
+    label?: string;
+    field: string;
+    shortField?: string;
+    values: FilterValue[];
+};
+declare const toFilter: (field: string, value: any) => Filter;
+declare const toShortFilter: (field: string, shortField: string, value: any) => Filter;
+type PageOptions = {
+    take?: number;
+    skip?: number;
+    sort?: Sort[];
+    sorts?: PlainSort;
+    filters?: Filter[];
+};
+type PageListOptions = Exclude<PageOptions, 'sort'> & {
+    total?: number;
+};
+declare class PageList<T> extends List<T> {
+    private _options?;
+    private setPageOptions;
+    get take(): number;
+    get skip(): number;
+    get total(): Optional<number>;
+    get sorts(): Optional<PlainSort>;
+    get filters(): Optional<Filter[]>;
+    get meta(): PageListOptions;
+    get options(): Optional<PageListOptions>;
+    asc(p: GetProperty<T, any>): PageList<T>;
+    desc(p: GetProperty<T, any>): PageList<T>;
+    diff(others: ArrayLike<T>): PageList<T>;
+    diffByKey(others: ArrayLike<T>, key: keyof T): PageList<T>;
+    intersect(others: ArrayLike<T>): PageList<T>;
+    intersectByKey(others: ArrayLike<T>, key: keyof T): PageList<T>;
+    map<U>(f: (value: T, index: number, array: T[]) => U, params?: unknown): PageList<U>;
+    flatMap<U, This = unknown>(f: (this: This, value: T, index: number, array: T[]) => ReadonlyArray<U> | U, params?: This): PageList<U>;
+    mapDefined<U>(f: (value: T, index: number, array: T[]) => U, params?: unknown): PageList<NonNullable<U>>;
+    mapAsync(f: (i: T) => Promise<T>): Promise<PageList<T>>;
+    distinct(): PageList<T>;
+    distinctByKey(key: keyof T): PageList<T>;
+    filter(p: (value: T, index: number, array: T[]) => unknown, params?: unknown): PageList<T>;
+    concat(...items: ConcatArray<T>[]): PageList<T>;
+    concat(...items: (T | ConcatArray<T>)[]): PageList<T>;
+    reverse(): PageList<T>;
+    splice(start: number, deleteCount?: number): PageList<T>;
+    splice(start: number, deleteCount: number, ...items: T[]): PageList<T>;
+    remove(item: T): PageList<T>;
+    replace(key: keyof T, item: T): PageList<T>;
+    switch(item: T): PageList<T>;
+    defined(): PageList<NonNullable<T>>;
+    orElse(...alt: ArrayLike<T>): Optional<PageList<T>>;
+    slice(start?: number, end?: number): PageList<T>;
+}
+declare const isPageList: <T>(l?: unknown) => l is PageList<T>;
+declare const toPageList: <T>(items?: T[], options?: Omit<PageOptions, 'sort'> & {
+    total?: number;
+}) => PageList<T>;
+declare const asPageList: <T, U>(c: Construct<T>, items?: PageList<U>) => PageList<T>;
+
+type FetchOptions = PageOptions;
+declare abstract class Gateway<Options = FetchOptions> {
+    all(options?: Options): Promise<PageList<Json>>;
+    byId(id: Id, options?: Options): Promise<Optional<Json>>;
+    by(_key: string, _value: JsonValue, _options?: Options): Promise<PageList<Json>>;
+    byIds(..._ids: Id[]): Promise<List<Json>>;
+    search(q: JsonValue, options?: Options): Promise<PageList<Json>>;
+    filter(options?: Options): Promise<PageList<Json>>;
+    exists(id: Id, options?: Options): Promise<boolean>;
+    add(item: Json, options?: Options): Promise<Json>;
+    update(item: Json, options?: Options): Promise<Json>;
+    remove(id: Id, options?: Options): Promise<boolean>;
+}
+
+declare const isDefined: <T = unknown>(o?: T | undefined) => o is NonNullable<T>;
+declare const isUndefined: (v?: unknown) => v is never;
+declare const isEmpty: (o?: unknown) => boolean;
+declare const isNotEmpty: <T = unknown>(o?: unknown) => o is NonNullable<T>;
+declare const isString: (o?: unknown) => o is string;
+declare const isIsoDateString: (o?: unknown) => o is string;
+declare const isBoolean: (o?: unknown) => o is boolean;
+declare const isTrue: (o?: unknown) => o is true;
+declare const isNumber: (o?: unknown) => o is number;
+declare const isObject: (o?: unknown) => o is Record<string, unknown>;
+declare const isEmptyObject: (o?: unknown) => boolean;
+declare const isFunction: (o?: unknown) => o is (...params: unknown[]) => unknown;
+declare const isArray: <T = any>(o?: unknown) => o is T[];
+declare const isInstance: <T>(ctor: Constructor<T>, o?: unknown) => o is T;
+declare const isIn: (o: unknown, values: unknown[]) => boolean;
+declare const isIntersecting: (o?: unknown[], values?: unknown[]) => boolean;
+declare const isError: (e: unknown) => e is Error;
+declare const isNotPresent: (...os: unknown[]) => boolean;
+declare const isPresent: (...os: unknown[]) => boolean;
+
+declare const isA: <T>(t?: unknown, ...properties: (keyof T)[]) => t is T;
+declare const isAn: <T>(t?: unknown, ...properties: (keyof T)[]) => t is T;
+
+declare const isDate: (o?: unknown) => o is Date;
+declare const days: {
+    add: (date: Date, days: number) => Date;
+    today: () => Date;
+    yesterday: () => Date;
+    tomorrow: () => Date;
+};
+declare const inPast: (o?: unknown) => boolean;
+declare const inFuture: (o?: unknown) => boolean;
+
+declare const isEqual: (one?: unknown, another?: unknown) => boolean;
+
+type Message<Args> = string | Func$1<string, Args>;
+declare const ofMessage: <Args>(g: Message<Args>, ...params: Args[]) => string;
+
+type MetaParseOptions = {
+    initial?: any;
+    skipUndefined?: boolean;
+};
+type Entry<T = unknown> = [key: string, value: T];
+declare class ClassMeta {
+    readonly subject: any;
+    private readonly data;
+    constructor(subject: any, data?: any);
+    get: <T>(key: string) => T;
+    set: <T>(key: string, value: T) => T;
+    entries: <T = unknown>() => List<Entry<T>>;
+    parse: <Out, Value>(f: (v: Value) => Out, options?: MetaParseOptions) => Record<string, Out>;
+    properties: (key?: string) => List<PropertyMeta>;
+    keys: <T = any>(key: string) => List<T>;
+    values: <T = unknown>() => List<T>;
+    property: (property: string | symbol) => PropertyMeta;
+}
+declare class PropertyMeta {
+    readonly subject: any;
+    readonly property: string | symbol;
+    private readonly data;
+    constructor(subject: any, property: string | symbol, data?: any);
+    get value(): any;
+    get: <T>(key: string) => Optional<T>;
+    set: <T>(key: string, value: T) => T;
+}
+declare const meta: (subject: unknown) => ClassMeta;
+declare const entries: <T = unknown>(subject: Record<string, T>) => List<Entry<T>>;
+
+type Nullish = null | undefined;
+declare const isNullish: (v?: unknown) => v is Nullish;
+
+declare const asNumber: (n: unknown, alt?: Get<number>) => number;
+
+type Primitive = string | number | bigint | boolean | symbol | null | undefined;
+declare const isPrimitive: (v?: unknown) => v is Primitive;
+
+declare class Repository<T, Options = FetchOptions> {
+    all(options?: Options): Promise<PageList<T>>;
+    byId(id: Id): Promise<T>;
+    byIds(...ids: Id[]): Promise<List<T>>;
+    byKey(key: Key, options?: Options): Promise<PageList<T>>;
+    by(key: keyof T, value: JsonValue, options?: Options): Promise<PageList<T>>;
+    search(q: JsonValue, options?: Options): Promise<PageList<T>>;
+    filter(options?: Options): Promise<PageList<T>>;
+    exists(id: Id): Promise<boolean>;
+    add(t: T | Json): Promise<T>;
+    update(id: Id, json: Json): Promise<T>;
+    remove(id: Id): Promise<boolean>;
+    upsert(id: Id, item: Json): Promise<T>;
+}
+
+declare const tag: (name: string) => PropertyDecorator;
+declare const searchable: () => PropertyDecorator;
+
+type TemplateOptions = {
+    type?: Text;
+    property?: Text;
+    actual?: Text;
+};
+declare const template: (tmpl: Text, subject: unknown, options?: TemplateOptions) => Text;
+
+declare abstract class Try<T = unknown> implements Validatable {
+    is: {
+        defined: (prop?: Func$1<unknown, T>) => Try<T>;
+        empty: (prop?: Func$1<unknown, T>) => Try<T>;
+        valid: (prop?: Func$1<unknown, T>) => Try<T>;
+        true: (prop?: Func$1<unknown, T>) => Try<T>;
+        false: (prop?: Func$1<unknown, T>) => Try<T>;
+        not: {
+            defined: (prop?: Func$1<unknown, T>) => Try<T>;
+            empty: (prop?: Func$1<unknown, T>) => Try<T>;
+            valid: (prop?: Func$1<unknown, T>) => Try<T>;
+        };
+    };
+    if: {
+        defined: (prop?: Func$1<unknown, T>) => Try<T>;
+        empty: (prop?: Func$1<unknown, T>) => Try<T>;
+        valid: (prop?: Func$1<unknown, T>) => Try<T>;
+        true: (prop?: Func$1<unknown, T>) => Try<T>;
+        false: (prop?: Func$1<unknown, T>) => Try<T>;
+        not: {
+            defined: (prop?: Func$1<unknown, T>) => Try<T>;
+            empty: (prop?: Func$1<unknown, T>) => Try<T>;
+            valid: (prop?: Func$1<unknown, T>) => Try<T>;
+        };
+    };
+    abstract get value(): T;
+    abstract get error(): Error;
+    abstract get isValid(): boolean;
+    static of: <T_1>(c: Get<T_1 | Try<T_1>>, ...args: unknown[]) => Try<T_1>;
+    abstract map<U>(f: Func$1<U | Try<U>, T>): Try<U>;
+    abstract recover(f: Func$1<T | Try<T>, Error>): Try<T>;
+    abstract recoverFrom(type: Constructor<Error>, f: Func$1<T | Try<T>, Error>): Try<T>;
+    abstract accept(f: Func$1<void, T>): Try<T>;
+    abstract filter(predicate: Func$1<boolean, T>): Try<T>;
+    abstract or(value: Get<T>): T;
+    abstract orElse(value?: Get<T>): Optional<T>;
+    abstract orThrow(error: Construct<Error>): T;
+}
+declare const tryTo: <T>(c: Get<T | Try<T>>, ...args: unknown[]) => Try<T>;
+
+type Segment = Text & {
+    key?: string;
+    segment?: string;
+    query?: (value: unknown) => string;
+};
+declare const toSegment: (key?: Text, { segment, query, }?: {
+    segment?: string | undefined;
+    query?: ((value: unknown) => string) | undefined;
+}) => Segment;
+declare const uri: {
+    host: (key?: string) => Segment;
+    resource: (resource: Uri) => Segment;
+    segment: (key?: Text) => Segment;
+    path: (key: Text) => Segment;
+    query: (key: Text) => Segment;
+    boolean: (key: Text) => Segment;
+};
+type Prop = {
+    segment: Segment;
+    value: any;
+};
+type Uri = {
+    id: (id?: unknown) => Uri;
+    ids: (ids: OneOrMore<unknown>) => Uri;
+    query: (q?: unknown) => Uri;
+    sort: (q?: any) => Uri;
+    skip: (n?: number) => Uri;
+    take: (n?: number) => Uri;
+    path: string;
+    route: (resource: string) => string;
+    isInternal: boolean;
+    toString: () => string;
+};
+type UriExpandProps = {
+    q: string;
+    s: string;
+};
+declare class EasyUri<Props = UriExpandProps> implements Uri {
+    readonly segments: Segment[];
+    static readonly id: Segment;
+    static readonly ids: Segment;
+    static readonly query: Segment;
+    static readonly sort: Segment;
+    static readonly skip: Segment;
+    static readonly take: Segment;
+    readonly host: Segment;
+    readonly resource: Segment;
+    protected state: any;
+    constructor(segments?: Segment[]);
+    get path(): string;
+    get complete(): string;
+    get isInternal(): boolean;
+    protected get props(): List<Prop>;
+    route: (resource?: Optional<string>) => string;
+    set: (segment: Segment, value?: unknown) => this;
+    toString(): string;
+    id: (id?: unknown) => this;
+    ids: (ids: OneOrMore<unknown>) => this;
+    query: (q?: unknown) => this;
+    sort: (s?: any) => this;
+    skip: (index?: number) => this;
+    take: (items?: number) => this;
+    expand(props: Partial<Props>): this;
+}
+
+declare class Value<V = string> implements Validatable {
+    readonly value: V;
+    constructor(value: V);
+    get isValid(): boolean;
+    toJSON(): JsonValue;
+    toString(): string;
+}
+declare const isValue: (v?: unknown) => v is Value<string>;
+
+declare class Convert<From = unknown, To = unknown> {
+    readonly from: (f: From) => To;
+    readonly to: (t: To) => From;
+    constructor(from: (f: From) => To, to: (t: To) => From);
+}
+declare const convert: {
+    default: Convert<any, any>;
+    ignore: Convert<any, any>;
+    toBool: {
+        fromNumber: Convert<boolean, number>;
+        fromString: Convert<boolean, string>;
+    };
+    toDate: {
+        fromString: Convert<string, string>;
+    };
+    toNumber: {
+        fromString: Convert<number, string>;
+    };
+};
+
+declare function ifTrue<Out, In = unknown>(o: unknown, f: Construct<Out, NonNullable<In>>, alt: Construct<Out>): Out;
+declare function ifTrue<Out, In = unknown>(o: unknown, f: Construct<Out, NonNullable<In>>, alt?: Construct<Out>): Optional<Out>;
+declare function ifFalse<Out, In = unknown>(o: unknown, f: Construct<Out, NonNullable<In>>, alt: Construct<Out>): Out;
+declare function ifFalse<Out, In = unknown>(o: unknown, f: Construct<Out, NonNullable<In>>, alt?: Construct<Out>): Optional<Out>;
+declare function ifDefined<Out, In = unknown>(o: Optional<In>, f: Construct<Out, NonNullable<In>>, alt: Construct<Out>): Out;
+declare function ifDefined<Out, In = unknown>(o: Optional<In>, f: Construct<Out, NonNullable<In>>, alt?: Construct<Out>): Optional<Out>;
+declare function ifNotEmpty<Out, In = unknown>(o: In, f: Construct<Out, NonNullable<In>>, alt: Construct<Out>): Out;
+declare function ifNotEmpty<Out, In = unknown>(o: In, f?: Construct<Out, NonNullable<In>>, alt?: Construct<Out>): Optional<Out>;
+declare function ifNotEmpty<Out, In = unknown>(o: In, f: Construct<Out, NonNullable<In>>, alt?: Construct<Out>): Optional<Out>;
+
+declare const isLoading: (...targets: unknown[]) => boolean;
+
+declare function log<T>(t: T): T;
+declare function log<T>(label: string, t: T): T;
+
+type PropertyOptions<T = unknown> = {
+    convert?: Convert<any, any>;
+    dflt?: Get<T>;
+    format?: string;
+};
+declare class Property<T = unknown> implements Mapping {
+    readonly property: string;
+    readonly options?: PropertyOptions<unknown> | undefined;
+    constructor(property: string, options?: PropertyOptions<unknown> | undefined);
+    in: (source?: Json) => JsonValue;
+    out: (source?: Json, key?: string) => JsonValue;
+    toString(): string;
+}
+
+declare class State {
+    protected readonly state: any;
+    constructor(state?: any);
+    protected get: <T>(key: string, alt?: Construct<T> | undefined) => T;
+    protected set: <T>(key: string, value: Construct<T>) => T;
+}
+
+type Mapping = {
+    property: string;
+    in: (source?: Json, key?: string) => Optional<JsonValue>;
+    out: (source?: Json, key?: string) => Optional<JsonValue>;
+};
+declare const isMapping: TypeGuard<Mapping>;
+type MapStartFrom = 'scratch' | 'source';
+type MapOptions = {
+    startFrom: MapStartFrom;
+};
+declare class Mapper extends State implements Mapping {
+    readonly options: MapOptions;
+    readonly property: string;
+    protected readonly map: {
+        item: (property: string, options?: PropertyOptions | undefined) => Property<unknown>;
+        ignore: (property?: string) => Mapping;
+        skipIn: (property: string) => Mapping;
+        skipOut: (property: string) => Mapping;
+        func: (property: string, funcIn: Get<Optional<JsonValue>, Json>, funcOut: Get<Optional<JsonValue>, Json>) => Mapping;
+        add: (funcIn: Get<JsonValue, Json>) => Mapping;
+        map: (mapper: Construct<Mapper>, property?: string) => Mapping;
+        propsToList: (...maps: Mapping[]) => Mapping;
+        list: (mapper: Mapping, property: string) => Mapping;
+    };
+    constructor(options?: MapOptions, property?: string);
+    get properties(): List<[string, Mapping]>;
+    get keys(): List<string>;
+    get columns(): List<string>;
+    private get droppedIn();
+    private get droppedOut();
+    in(from?: Json): Json;
+    out(to?: Json): Json;
+    toString(): string;
+}
+declare const mappings: {
+    item: (property: string, options?: PropertyOptions) => Property;
+    ignore: (property?: string) => Mapping;
+    skipIn: (property: string) => Mapping;
+    skipOut: (property: string) => Mapping;
+    func: (property: string, funcIn: Get<Optional<JsonValue>, Json>, funcOut: Get<Optional<JsonValue>, Json>) => Mapping;
+    add: (funcIn: Get<JsonValue, Json>) => Mapping;
+    map: (mapper: Construct<Mapper>, property?: string) => Mapping;
+    propsToList: (...maps: Mapping[]) => Mapping;
+    list: (mapper: Mapping, property: string) => Mapping;
+};
+
+type Pro<A> = A | PromiseLike<A>;
+declare const resolve: <S = unknown>(subject: S | PromiseLike<S>) => Promise<S>;
+declare const reject: <S = never>(e: ErrorOrigin) => Promise<S>;
+declare const tuple: {
+    2: <F, S>(first: Pro<F>, second: Pro<S>) => Promise<[Awaited<F>, Awaited<S>]>;
+    3: <F_1, S_1, T>(first: Pro<F_1>, second: Pro<S_1>, third: Pro<T>) => Promise<[Awaited<F_1>, Awaited<S_1>, Awaited<T>]>;
+    4: <F_2, S_2, T_1, Fo>(first: Pro<F_2>, second: Pro<S_2>, third: Pro<T_1>, forth: Pro<Fo>) => Promise<[Awaited<F_2>, Awaited<S_2>, Awaited<T_1>, Awaited<Fo>]>;
+    5: <F_3, S_3, T_2, Fo_1, Fi>(first: Pro<F_3>, second: Pro<S_3>, third: Pro<T_2>, forth: Pro<Fo_1>, fifth: Pro<Fi>) => Promise<[Awaited<F_3>, Awaited<S_3>, Awaited<T_2>, Awaited<Fo_1>, Awaited<Fi>]>;
+    all: <F_4, S_4>(first: Pro<F_4>, second: Pro<S_4>[]) => Promise<[Awaited<F_4>, S_4[]]>;
+    spread: <F_5, S_5>(first: Pro<F_5>, ...second: Pro<S_5>[]) => Promise<[Awaited<F_5>, S_5[]]>;
+};
+declare const tuple2: <F, S>(first: Pro<F>, second: Pro<S>) => Promise<[Awaited<F>, Awaited<S>]>;
+declare const tuple3: <F, S, T>(first: Pro<F>, second: Pro<S>, third: Pro<T>) => Promise<[Awaited<F>, Awaited<S>, Awaited<T>]>;
+declare const tuple4: <F, S, T, Fo>(first: Pro<F>, second: Pro<S>, third: Pro<T>, forth: Pro<Fo>) => Promise<[Awaited<F>, Awaited<S>, Awaited<T>, Awaited<Fo>]>;
+declare const tuple5: <F, S, T, Fo, Fi>(first: Pro<F>, second: Pro<S>, third: Pro<T>, forth: Pro<Fo>, fifth: Pro<Fi>) => Promise<[Awaited<F>, Awaited<S>, Awaited<T>, Awaited<Fo>, Awaited<Fi>]>;
+
+declare class Sentence implements Text {
+    private sentence;
+    constructor(word: Text, pre?: Sentence, sentence?: Text[]);
+    toString(): string;
+}
+declare class Topic extends Sentence {
+    it: Sentence;
+    anything: Sentence;
+    id: (id: Id) => Sentence;
+    your: (subject?: unknown) => Sentence;
+    a: (subject?: unknown) => Sentence;
+    an: (subject?: unknown) => Sentence;
+    any: (subjects?: unknown) => Sentence;
+}
+declare class Verb extends Sentence {
+    add: Topic;
+    check: Topic;
+    fetch: Topic;
+    find: Topic;
+    like: Topic;
+    process: Topic;
+    remove: Topic;
+    translate: Topic;
+    update: Topic;
+    validate: Topic;
+}
+declare class Not extends Verb {
+}
+declare class SupportVerb extends Verb {
+    not: Not;
+}
+declare class We extends Sentence {
+    could: SupportVerb;
+    did: SupportVerb;
+    added: Topic;
+    checked: Topic;
+    fetched: Topic;
+    found: Topic;
+    liked: Topic;
+    processed: Topic;
+    removed: Topic;
+    translated: Topic;
+    updated: Topic;
+    validated: Topic;
+}
+declare const we: We;
+
+declare const traverse: (subject?: unknown, property?: string) => unknown;
+
+type Func<T = unknown> = (a: any, key?: string) => T;
+type Viewer = {
+    key: string;
+    f: Func;
+};
+type ViewType = Primitive | Constructor | Func | View | undefined;
+declare const toViewer: (key: string, value: ViewType) => Viewer;
+declare class View<V = Json> {
+    private views;
+    readonly startsFrom: 'scratch' | 'source';
+    readonly viewers: Viewer[];
+    constructor(views?: Partial<Record<keyof V, ViewType>>, startsFrom?: 'scratch' | 'source', viewers?: Viewer[]);
+    get fromSource(): View<V>;
+    from<T = unknown>(source: PageList<T>): PageList<V>;
+    from<T = unknown>(source: List<T>): List<V>;
+    from<T = unknown>(source: T[]): V[];
+    from<T = unknown>(source: T): V;
+    same: (one?: unknown, another?: unknown) => boolean;
+    private reduce;
+}
+declare const isSimpleView: (a: unknown) => a is View<Json>;
+declare const view: <V = Json>(views: Partial<Record<keyof DontInfer<V>, ViewType>>) => View<V>;
+declare const views: {
+    ignore: symbol;
+    keep: symbol;
+    skip: symbol;
+    value: (value: unknown) => () => unknown;
+    or: {
+        key: (altKey: string) => (a: unknown, key?: string) => unknown;
+        value: (altValue: unknown) => (a: unknown, key?: string) => unknown;
+        func: (altFunc: Func) => (a: unknown, key?: string) => unknown;
+    };
+};
+
+declare class Wait {
+    static wait(ms?: number): Promise<void>;
+    static seconds(s?: number): Promise<void>;
+}
+declare const wait: (millis: number) => Promise<void>;
+
+declare class Condition {
+    readonly key: string;
+    readonly operator: string;
+    readonly value: unknown;
+    constructor(key: string, operator: string, value: unknown);
+    and: (...others: Condition[]) => LogicalCondition;
+    or: (...others: Condition[]) => LogicalCondition;
+    toJSON(): Json;
+}
+declare class LogicalCondition {
+    readonly operator: string;
+    readonly conditions: Condition[];
+    constructor(operator: string, conditions: Condition[]);
+    toJSON(): Json;
+}
+declare class SortCondition extends Condition implements Sort {
+    readonly key: string;
+    readonly value: -1 | 1;
+    constructor(key: string, value: -1 | 1);
+    toJSON(): Json;
+}
+declare const toCondition: (field: string, operator: string, value: unknown, conv?: Convert) => Condition;
+declare const isSortCondition: (s?: unknown) => s is SortCondition;
+
+declare class InMemoryGateway extends Gateway {
+    private readonly data;
+    constructor(data: Promise<PageList<Json>>);
+    all(options?: FetchOptions): Promise<PageList<Json>>;
+    byId(id: Id): Promise<Optional<Json>>;
+    by: (key: string, value: JsonValue) => Promise<PageList<Json>>;
+    exists(id: Id): Promise<boolean>;
+    add(item: Json): Promise<Json>;
+    remove(id: Id): Promise<true>;
+    update(item: Json): Promise<Json>;
+}
+
+type DataProvider = any;
+
+type DatabaseOptions = {
+    user?: string;
+    password?: string;
+    host?: string;
+    port?: number;
+    cluster?: string;
+    connectionString?: string;
+    maxPoolSize?: number;
+    minPoolSize?: number;
+    maxIdleTimeMS?: number;
+};
+declare class DefaultProvider implements DataProvider {
+}
+declare class Database extends Enum {
+    readonly provider: Constructor<DataProvider> | DataProvider;
+    readonly options?: DatabaseOptions | undefined;
+    static readonly Default: Database;
+    constructor(name: string, provider: Constructor<DataProvider> | DataProvider, options?: DatabaseOptions | undefined);
+    provide: <P>() => P;
+}
+
+declare class Field extends Property {
+    is: (value: unknown) => Condition;
+    isNot: (value: unknown) => Condition;
+    isIn: (...value: unknown[]) => Condition;
+    notIn: (...value: unknown[]) => Condition;
+    exists: (does: boolean) => Condition;
+    greater: (value: unknown) => Condition;
+    greaterEqual: (value: unknown) => Condition;
+    less: (value: unknown) => Condition;
+    lessEqual: (value: unknown) => Condition;
+    asc: () => SortCondition;
+    desc: () => SortCondition;
+    protected condition: (operator: string, value: unknown) => Condition;
+}
+declare const isField: (f?: unknown) => f is Field;
+
+type Query = Text;
+
+interface QueryProvider extends DataProvider {
+    query: (q: Query) => Promise<List<Json>>;
+    command: (q: Query) => Promise<number>;
+}
+
+declare class Country extends Enum {
+    private readonly lower;
+    static readonly AF: Country;
+    static readonly AX: Country;
+    static readonly AL: Country;
+    static readonly DZ: Country;
+    static readonly AS: Country;
+    static readonly AD: Country;
+    static readonly AO: Country;
+    static readonly AI: Country;
+    static readonly AQ: Country;
+    static readonly AG: Country;
+    static readonly AR: Country;
+    static readonly AM: Country;
+    static readonly AW: Country;
+    static readonly AU: Country;
+    static readonly AT: Country;
+    static readonly AZ: Country;
+    static readonly BS: Country;
+    static readonly BH: Country;
+    static readonly BD: Country;
+    static readonly BB: Country;
+    static readonly BY: Country;
+    static readonly BE: Country;
+    static readonly BZ: Country;
+    static readonly BJ: Country;
+    static readonly BM: Country;
+    static readonly BT: Country;
+    static readonly BO: Country;
+    static readonly BA: Country;
+    static readonly BW: Country;
+    static readonly BV: Country;
+    static readonly BR: Country;
+    static readonly IO: Country;
+    static readonly VG: Country;
+    static readonly BN: Country;
+    static readonly BG: Country;
+    static readonly BF: Country;
+    static readonly BI: Country;
+    static readonly KH: Country;
+    static readonly CM: Country;
+    static readonly CA: Country;
+    static readonly CV: Country;
+    static readonly BQ: Country;
+    static readonly KY: Country;
+    static readonly CF: Country;
+    static readonly TD: Country;
+    static readonly CL: Country;
+    static readonly CN: Country;
+    static readonly CX: Country;
+    static readonly CC: Country;
+    static readonly CO: Country;
+    static readonly KM: Country;
+    static readonly CG: Country;
+    static readonly CD: Country;
+    static readonly CK: Country;
+    static readonly CR: Country;
+    static readonly CI: Country;
+    static readonly HR: Country;
+    static readonly CU: Country;
+    static readonly CW: Country;
+    static readonly CY: Country;
+    static readonly CZ: Country;
+    static readonly DK: Country;
+    static readonly DJ: Country;
+    static readonly DM: Country;
+    static readonly DO: Country;
+    static readonly EC: Country;
+    static readonly EG: Country;
+    static readonly SV: Country;
+    static readonly GQ: Country;
+    static readonly ER: Country;
+    static readonly EE: Country;
+    static readonly SZ: Country;
+    static readonly ET: Country;
+    static readonly FK: Country;
+    static readonly FO: Country;
+    static readonly FJ: Country;
+    static readonly FI: Country;
+    static readonly FR: Country;
+    static readonly GF: Country;
+    static readonly PF: Country;
+    static readonly TF: Country;
+    static readonly GA: Country;
+    static readonly GM: Country;
+    static readonly GE: Country;
+    static readonly DE: Country;
+    static readonly GH: Country;
+    static readonly GI: Country;
+    static readonly GR: Country;
+    static readonly GL: Country;
+    static readonly GD: Country;
+    static readonly GP: Country;
+    static readonly GU: Country;
+    static readonly GT: Country;
+    static readonly GG: Country;
+    static readonly GN: Country;
+    static readonly GW: Country;
+    static readonly GY: Country;
+    static readonly HT: Country;
+    static readonly HM: Country;
+    static readonly HN: Country;
+    static readonly HK: Country;
+    static readonly HU: Country;
+    static readonly IS: Country;
+    static readonly IN: Country;
+    static readonly ID: Country;
+    static readonly IR: Country;
+    static readonly IQ: Country;
+    static readonly IE: Country;
+    static readonly IM: Country;
+    static readonly IL: Country;
+    static readonly IT: Country;
+    static readonly JM: Country;
+    static readonly JP: Country;
+    static readonly JE: Country;
+    static readonly JO: Country;
+    static readonly KZ: Country;
+    static readonly KE: Country;
+    static readonly KI: Country;
+    static readonly KW: Country;
+    static readonly KG: Country;
+    static readonly LA: Country;
+    static readonly LV: Country;
+    static readonly LB: Country;
+    static readonly LS: Country;
+    static readonly LR: Country;
+    static readonly LY: Country;
+    static readonly LI: Country;
+    static readonly LT: Country;
+    static readonly LU: Country;
+    static readonly MO: Country;
+    static readonly MG: Country;
+    static readonly MW: Country;
+    static readonly MY: Country;
+    static readonly MV: Country;
+    static readonly ML: Country;
+    static readonly MT: Country;
+    static readonly MH: Country;
+    static readonly MQ: Country;
+    static readonly MR: Country;
+    static readonly MU: Country;
+    static readonly YT: Country;
+    static readonly MX: Country;
+    static readonly FM: Country;
+    static readonly MD: Country;
+    static readonly MC: Country;
+    static readonly MN: Country;
+    static readonly ME: Country;
+    static readonly MS: Country;
+    static readonly MA: Country;
+    static readonly MZ: Country;
+    static readonly MM: Country;
+    static readonly NA: Country;
+    static readonly NR: Country;
+    static readonly NP: Country;
+    static readonly NL: Country;
+    static readonly NC: Country;
+    static readonly NZ: Country;
+    static readonly NI: Country;
+    static readonly NE: Country;
+    static readonly NG: Country;
+    static readonly NU: Country;
+    static readonly NF: Country;
+    static readonly KP: Country;
+    static readonly MK: Country;
+    static readonly MP: Country;
+    static readonly NO: Country;
+    static readonly OM: Country;
+    static readonly PK: Country;
+    static readonly PW: Country;
+    static readonly PS: Country;
+    static readonly PA: Country;
+    static readonly PG: Country;
+    static readonly PY: Country;
+    static readonly PE: Country;
+    static readonly PH: Country;
+    static readonly PN: Country;
+    static readonly PL: Country;
+    static readonly PT: Country;
+    static readonly PR: Country;
+    static readonly QA: Country;
+    static readonly RE: Country;
+    static readonly RO: Country;
+    static readonly RU: Country;
+    static readonly RW: Country;
+    static readonly WS: Country;
+    static readonly SM: Country;
+    static readonly ST: Country;
+    static readonly SA: Country;
+    static readonly SN: Country;
+    static readonly RS: Country;
+    static readonly SC: Country;
+    static readonly SL: Country;
+    static readonly SG: Country;
+    static readonly SX: Country;
+    static readonly SK: Country;
+    static readonly SI: Country;
+    static readonly SB: Country;
+    static readonly SO: Country;
+    static readonly ZA: Country;
+    static readonly GS: Country;
+    static readonly KR: Country;
+    static readonly SS: Country;
+    static readonly ES: Country;
+    static readonly LK: Country;
+    static readonly BL: Country;
+    static readonly SH: Country;
+    static readonly KN: Country;
+    static readonly LC: Country;
+    static readonly MF: Country;
+    static readonly PM: Country;
+    static readonly VC: Country;
+    static readonly SD: Country;
+    static readonly SR: Country;
+    static readonly SJ: Country;
+    static readonly SE: Country;
+    static readonly CH: Country;
+    static readonly SY: Country;
+    static readonly TW: Country;
+    static readonly TJ: Country;
+    static readonly TZ: Country;
+    static readonly TH: Country;
+    static readonly TL: Country;
+    static readonly TG: Country;
+    static readonly TK: Country;
+    static readonly TO: Country;
+    static readonly TT: Country;
+    static readonly TN: Country;
+    static readonly TR: Country;
+    static readonly TM: Country;
+    static readonly TC: Country;
+    static readonly TV: Country;
+    static readonly UM: Country;
+    static readonly VI: Country;
+    static readonly UG: Country;
+    static readonly UA: Country;
+    static readonly AE: Country;
+    static readonly GB: Country;
+    static readonly US: Country;
+    static readonly UY: Country;
+    static readonly UZ: Country;
+    static readonly VU: Country;
+    static readonly VA: Country;
+    static readonly VE: Country;
+    static readonly VN: Country;
+    static readonly WF: Country;
+    static readonly EH: Country;
+    static readonly YE: Country;
+    static readonly ZM: Country;
+    static readonly ZW: Country;
+    constructor(name: string, id: string, lower?: string);
+    static lookup(other: string): Optional<Country>;
+    equals<E extends Enum>(other: E | Id): other is E;
+}
+
+type DateTimeUnit = DateTimeUnit$1;
+type DiffOptions = {
+    rounding: 'floor' | 'ceil' | 'round';
+};
+declare class DateTime extends Value<Optional<string>> {
+    constructor(value?: string | number | Date, format?: string);
+    static get now(): DateTime;
+    get isValid(): boolean;
+    get fromNow(): string;
+    protected get utc(): DateTime$1;
+    protected get luxon(): DateTime$1;
+    from(date?: DateTime): string;
+    from(locale?: string): string;
+    from(date?: DateTime, locale?: string): string;
+    isAfter(dt: DateTime): boolean;
+    isBefore(dt: DateTime): boolean;
+    equals(dt: DateTime): boolean;
+    add(n: number, unit?: DateTimeUnit): DateTime;
+    subtract(n: number, unit?: DateTimeUnit): DateTime;
+    diff(other: DateTime, unit?: DateTimeUnit, opts?: DiffOptions): number;
+    startOf(unit?: DateTimeUnit): DateTime;
+    endOf(unit?: DateTimeUnit): DateTime;
+    withZone(zone: string): DateTime;
+    toString(): string;
+    toJSON(): JsonValue;
+    toFormat(format: string): string;
+    toLocale(locale?: string, format?: string): string;
+    toFull(locale?: string): string;
+    toDate(): Optional<Date>;
+}
+declare const isDateTime: (dt?: unknown) => dt is DateTime;
+declare const dt: (dt?: unknown) => DateTime;
+
+declare class EAN extends Value {
+    get isValid(): boolean;
+}
+declare const isEAN: (ean?: unknown) => boolean;
+
+declare class Email extends Value {
+    constructor(email?: unknown);
+    get isValid(): boolean;
+    get name(): string;
+}
+declare const email: (email?: unknown) => Email;
+declare const isEmail: (e?: unknown) => boolean;
+
+declare class IBAN extends Value {
+    get isValid(): boolean;
+}
+declare const isIBAN: (iban?: unknown) => boolean;
+
+declare class PostalCode extends Value {
+    readonly country: Country | Id;
+    constructor(postalCode?: unknown, country?: Country | Id);
+    get isValid(): boolean;
+}
+declare const postalCode: (postalCode?: unknown, country?: Country | Id) => PostalCode;
+
+interface UrlOptions {
+    protocols?: string[];
+    require_tld?: boolean;
+    require_protocol?: boolean;
+    require_host?: boolean;
+    require_port?: boolean;
+    require_valid_protocol?: boolean;
+    allow_underscores?: boolean;
+    host_whitelist?: Array<string | RegExp>;
+    host_blacklist?: Array<string | RegExp>;
+    allow_trailing_dot?: boolean;
+    allow_protocol_relative_urls?: boolean;
+    disallow_auth?: boolean;
+}
+declare class Url extends Value {
+    readonly options?: UrlOptions | undefined;
+    constructor(value: unknown, options?: UrlOptions | undefined);
+    get isValid(): boolean;
+}
+declare const url: (url: unknown, options?: UrlOptions) => Url;
+declare const isUrl: (url?: unknown, options?: UrlOptions) => boolean;
+
+declare abstract class Struct implements Validatable {
+    protected readonly state: any;
+    constructor(state?: any);
+    get isValid(): boolean;
+    toJSON(): Json;
+    toString(): string;
+    update(_add: Json): Struct;
+    protected merge(a: unknown): Json;
+}
+declare function isStruct(s?: unknown): s is Struct;
+
+declare class Address extends Struct {
+    readonly street: string;
+    readonly houseNumber: string;
+    readonly extension: string;
+    readonly postalCode: PostalCode;
+    readonly city: string;
+    readonly country: Country;
+    toString(): string;
+}
+declare const isAddress: (a?: unknown) => a is Address;
+
+declare class Dimension extends Struct {
+    readonly value: number;
+    readonly uom: UnitOfMeasurement;
+    static with: (value: number, uom?: UnitOfMeasurement) => Dimension;
+    sizeInMM(): number;
+    get inMilliMeters(): number;
+    gte(dim: Dimension): boolean;
+}
+
+declare class Box extends Struct {
+    readonly l: Dimension;
+    readonly w: Dimension;
+    readonly h: Dimension;
+    private readonly sorted;
+    lowestDim: Dimension;
+    medianDim: Dimension;
+    maxDim: Dimension;
+    get isValid(): boolean;
+    static with: (l: Dimension, w: Dimension, h: Dimension) => Box;
+    stack(qty: number): Box;
+    fits(contents: Box, qty?: number): boolean;
+}
+
+declare class Money extends Struct {
+    readonly currency: Currency;
+    readonly value: number;
+    add(amount: number): Money;
+    subtract(amount: number): Money;
+    times(n: number): Money;
+    toString(): string;
+}
+declare const money: (currency: Currency, value: number) => Money;
+declare const isMoney: (m?: unknown) => m is Money;
+
+declare class Name extends Struct {
+    readonly first: string;
+    readonly middle: string;
+    readonly last: string;
+    toString(): string;
+}
+declare const name: (n?: Json) => Name;
+
+declare class Weight extends Struct {
+    readonly value: number;
+    readonly uow: UnitOfWeight;
+    sizeInG(): number;
+    get inGrams(): number;
+    gte(w: Weight): boolean;
+    lte(w: Weight): boolean;
+    between(lower: Weight, upper?: Weight): boolean;
+    sum(add: Weight): Weight;
+}
+declare const weight: (value: number, uow?: UnitOfWeight) => Weight;
+
+declare class Currency extends Enum {
+    readonly digits: number;
+    constructor(id: string, name: string, digits: number, code: string);
+    static readonly EUR: Currency;
+    static readonly USD: Currency;
+    static readonly AED: Currency;
+    static readonly AFN: Currency;
+    static readonly ALL: Currency;
+    static readonly AMD: Currency;
+    static readonly ARS: Currency;
+    static readonly AUD: Currency;
+    static readonly AZN: Currency;
+    static readonly BAM: Currency;
+    static readonly BDT: Currency;
+    static readonly BGN: Currency;
+    static readonly BHD: Currency;
+    static readonly BIF: Currency;
+    static readonly BND: Currency;
+    static readonly BOB: Currency;
+    static readonly BRL: Currency;
+    static readonly BWP: Currency;
+    static readonly BYN: Currency;
+    static readonly BZD: Currency;
+    static readonly CAD: Currency;
+    static readonly CDF: Currency;
+    static readonly CHF: Currency;
+    static readonly CLP: Currency;
+    static readonly CNY: Currency;
+    static readonly COP: Currency;
+    static readonly CRC: Currency;
+    static readonly CVE: Currency;
+    static readonly CZK: Currency;
+    static readonly DJF: Currency;
+    static readonly DKK: Currency;
+    static readonly DOP: Currency;
+    static readonly DZD: Currency;
+    static readonly EEK: Currency;
+    static readonly EGP: Currency;
+    static readonly ERN: Currency;
+    static readonly ETB: Currency;
+    static readonly GBP: Currency;
+    static readonly GEL: Currency;
+    static readonly GHS: Currency;
+    static readonly GNF: Currency;
+    static readonly GTQ: Currency;
+    static readonly HKD: Currency;
+    static readonly HNL: Currency;
+    static readonly HRK: Currency;
+    static readonly HUF: Currency;
+    static readonly IDR: Currency;
+    static readonly ILS: Currency;
+    static readonly INR: Currency;
+    static readonly IQD: Currency;
+    static readonly IRR: Currency;
+    static readonly ISK: Currency;
+    static readonly JMD: Currency;
+    static readonly JOD: Currency;
+    static readonly JPY: Currency;
+    static readonly KES: Currency;
+    static readonly KHR: Currency;
+    static readonly KMF: Currency;
+    static readonly KRW: Currency;
+    static readonly KWD: Currency;
+    static readonly KZT: Currency;
+    static readonly LBP: Currency;
+    static readonly LKR: Currency;
+    static readonly LTL: Currency;
+    static readonly LVL: Currency;
+    static readonly LYD: Currency;
+    static readonly MAD: Currency;
+    static readonly MDL: Currency;
+    static readonly MGA: Currency;
+    static readonly MKD: Currency;
+    static readonly MMK: Currency;
+    static readonly MOP: Currency;
+    static readonly MUR: Currency;
+    static readonly MXN: Currency;
+    static readonly MYR: Currency;
+    static readonly MZN: Currency;
+    static readonly NAD: Currency;
+    static readonly NGN: Currency;
+    static readonly NIO: Currency;
+    static readonly NOK: Currency;
+    static readonly NPR: Currency;
+    static readonly NZD: Currency;
+    static readonly OMR: Currency;
+    static readonly PAB: Currency;
+    static readonly PEN: Currency;
+    static readonly PHP: Currency;
+    static readonly PKR: Currency;
+    static readonly PLN: Currency;
+    static readonly PYG: Currency;
+    static readonly QAR: Currency;
+    static readonly RON: Currency;
+    static readonly RSD: Currency;
+    static readonly RUB: Currency;
+    static readonly RWF: Currency;
+    static readonly SAR: Currency;
+    static readonly SDG: Currency;
+    static readonly SEK: Currency;
+    static readonly SGD: Currency;
+    static readonly SOS: Currency;
+    static readonly SYP: Currency;
+    static readonly THB: Currency;
+    static readonly TND: Currency;
+    static readonly TOP: Currency;
+    static readonly TRY: Currency;
+    static readonly TTD: Currency;
+    static readonly TWD: Currency;
+    static readonly TZS: Currency;
+    static readonly UAH: Currency;
+    static readonly UGX: Currency;
+    static readonly UYU: Currency;
+    static readonly UZS: Currency;
+    static readonly VEF: Currency;
+    static readonly VND: Currency;
+    static readonly XAF: Currency;
+    static readonly XOF: Currency;
+    static readonly YER: Currency;
+    static readonly ZAR: Currency;
+    static readonly ZMK: Currency;
+    static readonly ZWL: Currency;
+    amount: (amount?: number) => Money;
+    get zero(): Money;
+}
+
+declare class Environment extends Enum {
+    static readonly Dev: Environment;
+    static readonly Tst: Environment;
+    static readonly Acc: Environment;
+    static readonly Prd: Environment;
+}
+
+declare class Locale extends Enum {
+    readonly country: string;
+    private readonly lower;
+    static readonly AF: Locale;
+    static readonly AF_NA: Locale;
+    static readonly AF_ZA: Locale;
+    static readonly AK: Locale;
+    static readonly AK_GH: Locale;
+    static readonly SQ: Locale;
+    static readonly SQ_AL: Locale;
+    static readonly SQ_XK: Locale;
+    static readonly SQ_MK: Locale;
+    static readonly AM: Locale;
+    static readonly AM_ET: Locale;
+    static readonly AR: Locale;
+    static readonly AR_DZ: Locale;
+    static readonly AR_BH: Locale;
+    static readonly AR_TD: Locale;
+    static readonly AR_KM: Locale;
+    static readonly AR_DJ: Locale;
+    static readonly AR_EG: Locale;
+    static readonly AR_ER: Locale;
+    static readonly AR_IQ: Locale;
+    static readonly AR_IL: Locale;
+    static readonly AR_JO: Locale;
+    static readonly AR_KW: Locale;
+    static readonly AR_LB: Locale;
+    static readonly AR_LY: Locale;
+    static readonly AR_MR: Locale;
+    static readonly AR_MA: Locale;
+    static readonly AR_OM: Locale;
+    static readonly AR_PS: Locale;
+    static readonly AR_QA: Locale;
+    static readonly AR_SA: Locale;
+    static readonly AR_SO: Locale;
+    static readonly AR_SS: Locale;
+    static readonly AR_SD: Locale;
+    static readonly AR_SY: Locale;
+    static readonly AR_TN: Locale;
+    static readonly AR_AE: Locale;
+    static readonly AR_EH: Locale;
+    static readonly AR_YE: Locale;
+    static readonly HY: Locale;
+    static readonly HY_AM: Locale;
+    static readonly AS: Locale;
+    static readonly AS_IN: Locale;
+    static readonly AZ: Locale;
+    static readonly AZ_AZ: Locale;
+    static readonly AZ_CYRL_AZ: Locale;
+    static readonly AZ_CYRL: Locale;
+    static readonly AZ_LATN_AZ: Locale;
+    static readonly AZ_LATN: Locale;
+    static readonly BM: Locale;
+    static readonly BM_LATN_ML: Locale;
+    static readonly BM_LATN: Locale;
+    static readonly EU: Locale;
+    static readonly EU_ES: Locale;
+    static readonly BE: Locale;
+    static readonly BE_BY: Locale;
+    static readonly BN: Locale;
+    static readonly BN_BD: Locale;
+    static readonly BN_IN: Locale;
+    static readonly BS: Locale;
+    static readonly BS_BA: Locale;
+    static readonly BS_CYRL_BA: Locale;
+    static readonly BS_CYRL: Locale;
+    static readonly BS_LATN_BA: Locale;
+    static readonly BS_LATN: Locale;
+    static readonly BR: Locale;
+    static readonly BR_FR: Locale;
+    static readonly BG: Locale;
+    static readonly BG_BG: Locale;
+    static readonly MY: Locale;
+    static readonly MY_MM: Locale;
+    static readonly CA: Locale;
+    static readonly CA_AD: Locale;
+    static readonly CA_FR: Locale;
+    static readonly CA_IT: Locale;
+    static readonly CA_ES: Locale;
+    static readonly ZH: Locale;
+    static readonly ZH_CN: Locale;
+    static readonly ZH_HK: Locale;
+    static readonly ZH_MO: Locale;
+    static readonly ZH_HANS_CN: Locale;
+    static readonly ZH_HANS_HK: Locale;
+    static readonly ZH_HANS_MO: Locale;
+    static readonly ZH_HANS_SG: Locale;
+    static readonly ZH_HANS: Locale;
+    static readonly ZH_SG: Locale;
+    static readonly ZH_TW: Locale;
+    static readonly ZH_HANT_HK: Locale;
+    static readonly ZH_HANT_MO: Locale;
+    static readonly ZH_HANT_TW: Locale;
+    static readonly ZH_HANT: Locale;
+    static readonly KW: Locale;
+    static readonly KW_GB: Locale;
+    static readonly HR: Locale;
+    static readonly HR_BA: Locale;
+    static readonly HR_HR: Locale;
+    static readonly CS: Locale;
+    static readonly CS_CZ: Locale;
+    static readonly DA: Locale;
+    static readonly DA_DK: Locale;
+    static readonly DA_GL: Locale;
+    static readonly NL: Locale;
+    static readonly NL_AW: Locale;
+    static readonly NL_BE: Locale;
+    static readonly NL_BQ: Locale;
+    static readonly NL_CW: Locale;
+    static readonly NL_NL: Locale;
+    static readonly NL_SX: Locale;
+    static readonly NL_SR: Locale;
+    static readonly DZ: Locale;
+    static readonly DZ_BT: Locale;
+    static readonly EN: Locale;
+    static readonly EN_AS: Locale;
+    static readonly EN_AI: Locale;
+    static readonly EN_AG: Locale;
+    static readonly EN_AU: Locale;
+    static readonly EN_BS: Locale;
+    static readonly EN_BB: Locale;
+    static readonly EN_BE: Locale;
+    static readonly EN_BZ: Locale;
+    static readonly EN_BM: Locale;
+    static readonly EN_BW: Locale;
+    static readonly EN_IO: Locale;
+    static readonly EN_VG: Locale;
+    static readonly EN_CM: Locale;
+    static readonly EN_CA: Locale;
+    static readonly EN_KY: Locale;
+    static readonly EN_CX: Locale;
+    static readonly EN_CC: Locale;
+    static readonly EN_CK: Locale;
+    static readonly EN_DG: Locale;
+    static readonly EN_DM: Locale;
+    static readonly EN_ER: Locale;
+    static readonly EN_FK: Locale;
+    static readonly EN_FJ: Locale;
+    static readonly EN_GM: Locale;
+    static readonly EN_GH: Locale;
+    static readonly EN_GI: Locale;
+    static readonly EN_GD: Locale;
+    static readonly EN_GU: Locale;
+    static readonly EN_GG: Locale;
+    static readonly EN_GY: Locale;
+    static readonly EN_HK: Locale;
+    static readonly EN_IN: Locale;
+    static readonly EN_IE: Locale;
+    static readonly EN_IM: Locale;
+    static readonly EN_JM: Locale;
+    static readonly EN_JE: Locale;
+    static readonly EN_KE: Locale;
+    static readonly EN_KI: Locale;
+    static readonly EN_LS: Locale;
+    static readonly EN_LR: Locale;
+    static readonly EN_MO: Locale;
+    static readonly EN_MG: Locale;
+    static readonly EN_MW: Locale;
+    static readonly EN_MY: Locale;
+    static readonly EN_MT: Locale;
+    static readonly EN_MH: Locale;
+    static readonly EN_MU: Locale;
+    static readonly EN_FM: Locale;
+    static readonly EN_MS: Locale;
+    static readonly EN_NA: Locale;
+    static readonly EN_NR: Locale;
+    static readonly EN_NZ: Locale;
+    static readonly EN_NG: Locale;
+    static readonly EN_NU: Locale;
+    static readonly EN_NF: Locale;
+    static readonly EN_MP: Locale;
+    static readonly EN_PK: Locale;
+    static readonly EN_PW: Locale;
+    static readonly EN_PG: Locale;
+    static readonly EN_PH: Locale;
+    static readonly EN_PN: Locale;
+    static readonly EN_PR: Locale;
+    static readonly EN_RW: Locale;
+    static readonly EN_WS: Locale;
+    static readonly EN_SC: Locale;
+    static readonly EN_SL: Locale;
+    static readonly EN_SG: Locale;
+    static readonly EN_SX: Locale;
+    static readonly EN_SB: Locale;
+    static readonly EN_ZA: Locale;
+    static readonly EN_SS: Locale;
+    static readonly EN_SH: Locale;
+    static readonly EN_KN: Locale;
+    static readonly EN_LC: Locale;
+    static readonly EN_VC: Locale;
+    static readonly EN_SD: Locale;
+    static readonly EN_SZ: Locale;
+    static readonly EN_TZ: Locale;
+    static readonly EN_TK: Locale;
+    static readonly EN_TO: Locale;
+    static readonly EN_TT: Locale;
+    static readonly EN_TC: Locale;
+    static readonly EN_TV: Locale;
+    static readonly EN_UM: Locale;
+    static readonly EN_VI: Locale;
+    static readonly EN_UG: Locale;
+    static readonly EN_GB: Locale;
+    static readonly EN_US: Locale;
+    static readonly EN_VU: Locale;
+    static readonly EN_ZM: Locale;
+    static readonly EN_ZW: Locale;
+    static readonly EO: Locale;
+    static readonly ET: Locale;
+    static readonly ET_EE: Locale;
+    static readonly EE: Locale;
+    static readonly EE_GH: Locale;
+    static readonly EE_TG: Locale;
+    static readonly FO: Locale;
+    static readonly FO_FO: Locale;
+    static readonly FI: Locale;
+    static readonly FI_FI: Locale;
+    static readonly FR: Locale;
+    static readonly FR_DZ: Locale;
+    static readonly FR_BE: Locale;
+    static readonly FR_BJ: Locale;
+    static readonly FR_BF: Locale;
+    static readonly FR_BI: Locale;
+    static readonly FR_CM: Locale;
+    static readonly FR_CA: Locale;
+    static readonly FR_CF: Locale;
+    static readonly FR_TD: Locale;
+    static readonly FR_KM: Locale;
+    static readonly FR_CG: Locale;
+    static readonly FR_CD: Locale;
+    static readonly FR_CI: Locale;
+    static readonly FR_DJ: Locale;
+    static readonly FR_GQ: Locale;
+    static readonly FR_FR: Locale;
+    static readonly FR_GF: Locale;
+    static readonly FR_PF: Locale;
+    static readonly FR_GA: Locale;
+    static readonly FR_GP: Locale;
+    static readonly FR_GN: Locale;
+    static readonly FR_HT: Locale;
+    static readonly FR_LU: Locale;
+    static readonly FR_MG: Locale;
+    static readonly FR_ML: Locale;
+    static readonly FR_MQ: Locale;
+    static readonly FR_MR: Locale;
+    static readonly FR_MU: Locale;
+    static readonly FR_YT: Locale;
+    static readonly FR_MC: Locale;
+    static readonly FR_MA: Locale;
+    static readonly FR_NC: Locale;
+    static readonly FR_NE: Locale;
+    static readonly FR_RE: Locale;
+    static readonly FR_RW: Locale;
+    static readonly FR_SN: Locale;
+    static readonly FR_SC: Locale;
+    static readonly FR_BL: Locale;
+    static readonly FR_MF: Locale;
+    static readonly FR_PM: Locale;
+    static readonly FR_CH: Locale;
+    static readonly FR_SY: Locale;
+    static readonly FR_TG: Locale;
+    static readonly FR_TN: Locale;
+    static readonly FR_VU: Locale;
+    static readonly FR_WF: Locale;
+    static readonly FF: Locale;
+    static readonly FF_CM: Locale;
+    static readonly FF_GN: Locale;
+    static readonly FF_MR: Locale;
+    static readonly FF_SN: Locale;
+    static readonly GL: Locale;
+    static readonly GL_ES: Locale;
+    static readonly LG: Locale;
+    static readonly LG_UG: Locale;
+    static readonly KA: Locale;
+    static readonly KA_GE: Locale;
+    static readonly DE: Locale;
+    static readonly DE_AT: Locale;
+    static readonly DE_BE: Locale;
+    static readonly DE_DE: Locale;
+    static readonly DE_LI: Locale;
+    static readonly DE_LU: Locale;
+    static readonly DE_CH: Locale;
+    static readonly EL: Locale;
+    static readonly EL_CY: Locale;
+    static readonly EL_GR: Locale;
+    static readonly GU: Locale;
+    static readonly GU_IN: Locale;
+    static readonly HA: Locale;
+    static readonly HA_GH: Locale;
+    static readonly HA_LATN_GH: Locale;
+    static readonly HA_LATN_NE: Locale;
+    static readonly HA_LATN_NG: Locale;
+    static readonly HA_LATN: Locale;
+    static readonly HA_NE: Locale;
+    static readonly HA_NG: Locale;
+    static readonly HE: Locale;
+    static readonly HE_IL: Locale;
+    static readonly HI: Locale;
+    static readonly HI_IN: Locale;
+    static readonly HU: Locale;
+    static readonly HU_HU: Locale;
+    static readonly IS: Locale;
+    static readonly IS_IS: Locale;
+    static readonly IG: Locale;
+    static readonly IG_NG: Locale;
+    static readonly ID: Locale;
+    static readonly ID_ID: Locale;
+    static readonly GA: Locale;
+    static readonly GA_IE: Locale;
+    static readonly IT: Locale;
+    static readonly IT_IT: Locale;
+    static readonly IT_SM: Locale;
+    static readonly IT_CH: Locale;
+    static readonly JA: Locale;
+    static readonly JA_JP: Locale;
+    static readonly KL: Locale;
+    static readonly KL_GL: Locale;
+    static readonly KN: Locale;
+    static readonly KN_IN: Locale;
+    static readonly KS: Locale;
+    static readonly KS_ARAB_IN: Locale;
+    static readonly KS_ARAB: Locale;
+    static readonly KS_IN: Locale;
+    static readonly KK: Locale;
+    static readonly KK_CYRL_KZ: Locale;
+    static readonly KK_CYRL: Locale;
+    static readonly KK_KZ: Locale;
+    static readonly KM: Locale;
+    static readonly KM_KH: Locale;
+    static readonly KI: Locale;
+    static readonly KI_KE: Locale;
+    static readonly RW: Locale;
+    static readonly RW_RW: Locale;
+    static readonly KO: Locale;
+    static readonly KO_KP: Locale;
+    static readonly KO_KR: Locale;
+    static readonly KY: Locale;
+    static readonly KY_CYRL_KG: Locale;
+    static readonly KY_CYRL: Locale;
+    static readonly KY_KG: Locale;
+    static readonly LO: Locale;
+    static readonly LO_LA: Locale;
+    static readonly LV: Locale;
+    static readonly LV_LV: Locale;
+    static readonly LN: Locale;
+    static readonly LN_AO: Locale;
+    static readonly LN_CF: Locale;
+    static readonly LN_CG: Locale;
+    static readonly LN_CD: Locale;
+    static readonly LT: Locale;
+    static readonly LT_LT: Locale;
+    static readonly LU: Locale;
+    static readonly LU_CD: Locale;
+    static readonly LB: Locale;
+    static readonly LB_LU: Locale;
+    static readonly MK: Locale;
+    static readonly MK_MK: Locale;
+    static readonly MG: Locale;
+    static readonly MG_MG: Locale;
+    static readonly MS: Locale;
+    static readonly MS_BN: Locale;
+    static readonly MS_LATN_BN: Locale;
+    static readonly MS_LATN_MY: Locale;
+    static readonly MS_LATN_SG: Locale;
+    static readonly MS_LATN: Locale;
+    static readonly MS_MY: Locale;
+    static readonly MS_SG: Locale;
+    static readonly ML: Locale;
+    static readonly ML_IN: Locale;
+    static readonly MT: Locale;
+    static readonly MT_MT: Locale;
+    static readonly GV: Locale;
+    static readonly GV_IM: Locale;
+    static readonly MR: Locale;
+    static readonly MR_IN: Locale;
+    static readonly MN: Locale;
+    static readonly MN_CYRL_MN: Locale;
+    static readonly MN_CYRL: Locale;
+    static readonly MN_MN: Locale;
+    static readonly NE: Locale;
+    static readonly NE_IN: Locale;
+    static readonly NE_NP: Locale;
+    static readonly ND: Locale;
+    static readonly ND_ZW: Locale;
+    static readonly SE: Locale;
+    static readonly SE_FI: Locale;
+    static readonly SE_NO: Locale;
+    static readonly SE_SE: Locale;
+    static readonly NO: Locale;
+    static readonly NO_NO: Locale;
+    static readonly NB: Locale;
+    static readonly NB_NO: Locale;
+    static readonly NB_SJ: Locale;
+    static readonly NN: Locale;
+    static readonly NN_NO: Locale;
+    static readonly OR: Locale;
+    static readonly OR_IN: Locale;
+    static readonly OM: Locale;
+    static readonly OM_ET: Locale;
+    static readonly OM_KE: Locale;
+    static readonly OS: Locale;
+    static readonly OS_GE: Locale;
+    static readonly OS_RU: Locale;
+    static readonly PS: Locale;
+    static readonly PS_AF: Locale;
+    static readonly FA: Locale;
+    static readonly FA_AF: Locale;
+    static readonly FA_IR: Locale;
+    static readonly PL: Locale;
+    static readonly PL_PL: Locale;
+    static readonly PT: Locale;
+    static readonly PT_AO: Locale;
+    static readonly PT_BR: Locale;
+    static readonly PT_CV: Locale;
+    static readonly PT_GW: Locale;
+    static readonly PT_MO: Locale;
+    static readonly PT_MZ: Locale;
+    static readonly PT_PT: Locale;
+    static readonly PT_ST: Locale;
+    static readonly PT_TL: Locale;
+    static readonly PA: Locale;
+    static readonly PA_ARAB_PK: Locale;
+    static readonly PA_ARAB: Locale;
+    static readonly PA_GURU_IN: Locale;
+    static readonly PA_GURU: Locale;
+    static readonly PA_IN: Locale;
+    static readonly PA_PK: Locale;
+    static readonly QU: Locale;
+    static readonly QU_BO: Locale;
+    static readonly QU_EC: Locale;
+    static readonly QU_PE: Locale;
+    static readonly RO: Locale;
+    static readonly RO_MD: Locale;
+    static readonly RO_RO: Locale;
+    static readonly RM: Locale;
+    static readonly RM_CH: Locale;
+    static readonly RN: Locale;
+    static readonly RN_BI: Locale;
+    static readonly RU: Locale;
+    static readonly RU_BY: Locale;
+    static readonly RU_KZ: Locale;
+    static readonly RU_KG: Locale;
+    static readonly RU_MD: Locale;
+    static readonly RU_RU: Locale;
+    static readonly RU_UA: Locale;
+    static readonly SG: Locale;
+    static readonly SG_CF: Locale;
+    static readonly GD: Locale;
+    static readonly GD_GB: Locale;
+    static readonly SR: Locale;
+    static readonly SR_BA: Locale;
+    static readonly SR_CYRL_BA: Locale;
+    static readonly SR_CYRL_XK: Locale;
+    static readonly SR_CYRL_ME: Locale;
+    static readonly SR_CYRL_RS: Locale;
+    static readonly SR_CYRL: Locale;
+    static readonly SR_XK: Locale;
+    static readonly SR_LATN_BA: Locale;
+    static readonly SR_LATN_XK: Locale;
+    static readonly SR_LATN_ME: Locale;
+    static readonly SR_LATN_RS: Locale;
+    static readonly SR_LATN: Locale;
+    static readonly SR_ME: Locale;
+    static readonly SR_RS: Locale;
+    static readonly SH: Locale;
+    static readonly SH_BA: Locale;
+    static readonly SN: Locale;
+    static readonly SN_ZW: Locale;
+    static readonly II: Locale;
+    static readonly II_CN: Locale;
+    static readonly SI: Locale;
+    static readonly SI_LK: Locale;
+    static readonly SK: Locale;
+    static readonly SK_SK: Locale;
+    static readonly SL: Locale;
+    static readonly SL_SI: Locale;
+    static readonly SO: Locale;
+    static readonly SO_DJ: Locale;
+    static readonly SO_ET: Locale;
+    static readonly SO_KE: Locale;
+    static readonly SO_SO: Locale;
+    static readonly ES: Locale;
+    static readonly ES_AR: Locale;
+    static readonly ES_BO: Locale;
+    static readonly ES_IC: Locale;
+    static readonly ES_EA: Locale;
+    static readonly ES_CL: Locale;
+    static readonly ES_CO: Locale;
+    static readonly ES_CR: Locale;
+    static readonly ES_CU: Locale;
+    static readonly ES_DO: Locale;
+    static readonly ES_EC: Locale;
+    static readonly ES_SV: Locale;
+    static readonly ES_GQ: Locale;
+    static readonly ES_GT: Locale;
+    static readonly ES_HN: Locale;
+    static readonly ES_MX: Locale;
+    static readonly ES_NI: Locale;
+    static readonly ES_PA: Locale;
+    static readonly ES_PY: Locale;
+    static readonly ES_PE: Locale;
+    static readonly ES_PH: Locale;
+    static readonly ES_PR: Locale;
+    static readonly ES_ES: Locale;
+    static readonly ES_US: Locale;
+    static readonly ES_UY: Locale;
+    static readonly ES_VE: Locale;
+    static readonly SW: Locale;
+    static readonly SW_KE: Locale;
+    static readonly SW_TZ: Locale;
+    static readonly SW_UG: Locale;
+    static readonly SV: Locale;
+    static readonly SV_AX: Locale;
+    static readonly SV_FI: Locale;
+    static readonly SV_SE: Locale;
+    static readonly TL: Locale;
+    static readonly TL_PH: Locale;
+    static readonly TA: Locale;
+    static readonly TA_IN: Locale;
+    static readonly TA_MY: Locale;
+    static readonly TA_SG: Locale;
+    static readonly TA_LK: Locale;
+    static readonly TE: Locale;
+    static readonly TE_IN: Locale;
+    static readonly TH: Locale;
+    static readonly TH_TH: Locale;
+    static readonly BO: Locale;
+    static readonly BO_CN: Locale;
+    static readonly BO_IN: Locale;
+    static readonly TI: Locale;
+    static readonly TI_ER: Locale;
+    static readonly TI_ET: Locale;
+    static readonly TO: Locale;
+    static readonly TO_TO: Locale;
+    static readonly TR: Locale;
+    static readonly TR_CY: Locale;
+    static readonly TR_TR: Locale;
+    static readonly UK: Locale;
+    static readonly UK_UA: Locale;
+    static readonly UR: Locale;
+    static readonly UR_IN: Locale;
+    static readonly UR_PK: Locale;
+    static readonly UG: Locale;
+    static readonly UG_ARAB_CN: Locale;
+    static readonly UG_ARAB: Locale;
+    static readonly UG_CN: Locale;
+    static readonly UZ: Locale;
+    static readonly UZ_AF: Locale;
+    static readonly UZ_ARAB_AF: Locale;
+    static readonly UZ_ARAB: Locale;
+    static readonly UZ_CYRL_UZ: Locale;
+    static readonly UZ_CYRL: Locale;
+    static readonly UZ_LATN_UZ: Locale;
+    static readonly UZ_LATN: Locale;
+    static readonly UZ_UZ: Locale;
+    static readonly VI: Locale;
+    static readonly VI_VN: Locale;
+    static readonly CY: Locale;
+    static readonly CY_GB: Locale;
+    static readonly FY: Locale;
+    static readonly FY_NL: Locale;
+    static readonly YI: Locale;
+    static readonly YO: Locale;
+    static readonly YO_BJ: Locale;
+    static readonly YO_NG: Locale;
+    static readonly ZU: Locale;
+    static readonly ZU_ZA: Locale;
+    constructor(id: Id, name: string, country?: string, lower?: string);
+    static lookup(other: string): Optional<Locale>;
+    equals<E extends Enum>(other: E | Id): other is E;
+}
+
+declare class UnitOfMeasurement extends Enum {
+    readonly mmMultiplier: number;
+    static readonly MM: UnitOfMeasurement;
+    static readonly CM: UnitOfMeasurement;
+    static readonly DM: UnitOfMeasurement;
+    static readonly M: UnitOfMeasurement;
+    static readonly KM: UnitOfMeasurement;
+    constructor(name: string, id: string, mmMultiplier: number);
+}
+
+declare class UnitOfWeight extends Enum {
+    readonly gMultiplier: number;
+    static readonly MG: UnitOfWeight;
+    static readonly G: UnitOfWeight;
+    static readonly KG: UnitOfWeight;
+    constructor(name: string, id: string, gMultiplier: number);
+}
+
+declare class Audit extends Struct {
+    readonly by: {
+        id: Id;
+        user: string;
+    };
+    readonly when: DateTime;
+    constructor(json?: Json);
+}
+
+declare abstract class Child extends Struct {
+    readonly id: Id;
+    protected merge(a: unknown): Json;
+}
+
+declare abstract class Entity extends Struct {
+    readonly id: Id;
+    readonly created: Audit;
+    readonly lastModified: Audit;
+    protected merge(a: unknown): Json;
+}
+
+type RepoAction = 'add' | 'update' | 'remove';
+declare class Repo<T extends Struct, Options = FetchOptions> extends Repository<T, Options> {
+    protected ctor: Constructor<T>;
+    private readonly gateway;
+    constructor(ctor: Constructor<T>, gateway: Gateway<Options>);
+    create: (item: T | Json) => T;
+    all(options?: Options): Promise<PageList<T>>;
+    byId(id: Id): Promise<T>;
+    byIds(...ids: Id[]): Promise<List<T>>;
+    byKey(key: Key, options?: Options): Promise<PageList<T>>;
+    by(key: keyof T, value: JsonValue, options?: Options): Promise<PageList<T>>;
+    search(q: JsonValue, options?: Options): Promise<PageList<T>>;
+    filter(options?: Options): Promise<PageList<T>>;
+    exists(id: Id): Promise<boolean>;
+    add(t: T | Json): Promise<T>;
+    update(id: Id, json: Json): Promise<T>;
+    remove(id: Id): Promise<boolean>;
+    extend(item: T, _action?: RepoAction): Promise<T>;
+    validate(item: T, _action?: RepoAction): Promise<T>;
+    upsert(id: Id, item: Json): Promise<T>;
+}
+
+declare class Typo<T, Options = FetchOptions> extends Repository<T, Options> {
+    protected view: View<T>;
+    private readonly gateway;
+    constructor(view: View<T>, gateway: Gateway<Options>);
+    create: (j: Json) => T;
+    all(options?: Options): Promise<PageList<T>>;
+    byId(id: Id): Promise<T>;
+    byIds(...ids: Id[]): Promise<List<T>>;
+    byKey(key: Key, options?: Options): Promise<PageList<T>>;
+    by(key: keyof T, value: JsonValue, options?: Options): Promise<PageList<T>>;
+    search(q: JsonValue, options?: Options): Promise<PageList<T>>;
+    filter(options?: Options): Promise<PageList<T>>;
+    exists(id: Id): Promise<boolean>;
+}
+
+type Resource = any;
+
+declare class Service extends Enum {
+    readonly name: string;
+    protected app: AppProvider;
+    protected resources: List<Resource>;
+    protected port: number;
+    constructor(name: string, app: AppProvider, resources?: List<Resource>);
+    pre: () => Handler[];
+    post: () => Handler[];
+    with(...resources: Constructor<Resource>[]): this;
+    atPort(port: number): this;
+    start(message?: string): void;
+}
+
+type Handler = Func$1<void, any>;
+interface AppProvider {
+    use: (h: Handler) => void;
+    route: (s: Service, r: Resource) => void;
+    listen: (port: number, message?: string) => void;
+}
+
+declare class Req implements Omit<PageOptions, 'sort'> {
+    readonly path: Json;
+    readonly query: Json;
+    readonly body: unknown;
+    readonly headers: Record<string, OneOrMore<string>>;
+    constructor(path: Json, query: Json, body: unknown, headers: Record<string, OneOrMore<string>>);
+    get id(): Id;
+    get skip(): number | undefined;
+    get take(): number | undefined;
+    get q(): JsonValue;
+    get: (key: Text) => any;
+}
+declare const toReq: (req: {
+    params?: {
+        id?: unknown;
+    };
+    query?: {
+        q?: unknown;
+    };
+    body?: unknown;
+    headers?: unknown;
+}) => Req;
+
+declare class Scope extends Enum {
+    readonly name: string;
+    protected constructor(name: string, id?: Text);
+}
+
+declare class App extends Scope {
+    constructor(name: string);
+    static readonly Main: App;
+}
+
+declare class Search<T, Options = FetchOptions> {
+    protected repo: Repository<T, Options>;
+    constructor(repo: Repository<T, Options>);
+    all(options?: Options): Promise<PageList<T>>;
+    byId(id: Id): Promise<T>;
+    byIds(...ids: Id[]): Promise<List<T>>;
+    byKey(key: Key, options?: Options): Promise<PageList<T>>;
+    query({ query, skip, take }: Req): Promise<PageList<T>>;
+    search(query: JsonValue, options?: Options): Promise<PageList<T>>;
+    filter(options?: Options): Promise<PageList<T>>;
+    exists(id: Id): Promise<boolean>;
+}
+
+declare class Manage<T, Options = FetchOptions> extends Search<T, Options> {
+    add(json: Json): Promise<T>;
+    update(id: Id, json: Json): Promise<T>;
+    upsert(id: Id, json: Json): Promise<T>;
+    remove(id: Id): Promise<boolean>;
+}
+
+declare class UseCase extends Enum {
+    readonly app: App;
+    readonly scopes: List<Scope>;
+    constructor(app: App, name: string, id?: Text, scopes?: List<Scope>);
+    with(...s: Scope[]): this;
+    static byScopes<U extends UseCase>(...s: Scope[]): List<U>;
+}
+
+declare class Requires {
+    readonly labCoat: () => PropertyDecorator;
+    readonly token: () => PropertyDecorator;
+    readonly scope: (scope: Scope) => PropertyDecorator;
+    readonly useCase: (uc: UseCase) => PropertyDecorator;
+}
+declare const requires: Requires;
+
+declare const route: (uri: Uri) => ClassDecorator;
+type Endpoint<T = unknown> = (re: Req) => Promise<T | List<T>>;
+type RouteRequires = {
+    token: boolean;
+    labCoat: boolean;
+    scope?: Scope;
+    uc?: UseCase;
+};
+type Route = {
+    verb: Verb$1;
+    endpoint: Endpoint;
+    requires: RouteRequires;
+    middleware: RequestHandler[];
+};
+type Routes = {
+    route: Uri;
+    middleware: RequestHandler[];
+    endpoints: List<Route>;
+};
+declare const routes: (resource: Resource) => Routes;
+
+declare class HealthResource implements Resource {
+    ok: () => Promise<Json>;
+}
+
+declare class HealthUri extends EasyUri {
+    static readonly health: Segment;
+    static readonly Health: HealthUri;
+}
+
+type RouteOptions = RequestOptions | FetchOptions;
+declare class Api {
+    readonly provider: RequestProvider;
+    protected store?: Store<Response, Request> | undefined;
+    constructor(provider?: RequestProvider, store?: Store<Response, Request> | undefined);
+    get(uri: Uri, options?: RouteOptions, transform?: (r: any) => any, transformError?: (r: any) => any): Promise<Response>;
+    post(uri: Uri, body?: unknown, options?: RouteOptions, transform?: (r: any) => any, transformError?: (r: any) => any): Promise<Response>;
+    put(uri: Uri, body?: unknown, options?: RouteOptions, transform?: (r: any) => any, transformError?: (r: any) => any): Promise<Response>;
+    patch(uri: Uri, body?: unknown, options?: RouteOptions, transform?: (r: any) => any, transformError?: (r: any) => any): Promise<Response>;
+    delete(uri: Uri, options?: RouteOptions, transform?: (b: any) => any, transformError?: (r: any) => any): Promise<Response>;
+    options(verb: HttpVerb, options?: RouteOptions): RequestOptions;
+    execute(req: Request): Promise<Response>;
+}
+declare const api: Api;
+
+declare class ApiGateway extends Gateway<RouteOptions> {
+    readonly api: Api;
+    constructor(api?: Api);
+    get(uri: Uri, options?: RouteOptions): Promise<PageList<Json>>;
+    getOne(uri: Uri, options?: RouteOptions): Promise<Optional<Json>>;
+    post(uri: Uri, item?: Json, options?: RouteOptions): Promise<Json>;
+    postSearch(uri: Uri, options?: RequestOptions | FetchOptions): Promise<PageList<Json>>;
+    patch(uri: Uri, item?: Json, options?: RouteOptions): Promise<Json>;
+    put(uri: Uri, item?: Json, options?: RouteOptions): Promise<Json>;
+    delete(uri: Uri, options?: RouteOptions): Promise<boolean>;
+}
+
+declare class AxiosProvider implements RequestProvider {
+    readonly ai: AxiosInstance;
+    constructor(ai?: AxiosInstance);
+    execute: ({ uri, verb, body, transform, transformError, options }: Request) => Promise<Response>;
+}
+
+declare class RouteGateway extends ApiGateway {
+    readonly route: Func$1<Uri>;
+    readonly routeId: Func$1<Uri>;
+    readonly api: Api;
+    constructor(route: Func$1<Uri>, routeId: Func$1<Uri>, api?: Api);
+    all(options?: RouteOptions): Promise<PageList<Json>>;
+    byId(id: Id, options?: RouteOptions): Promise<Optional<Json>>;
+    byIds(...ids: Id[]): Promise<List<Json>>;
+    search(q: JsonValue, options?: RouteOptions): Promise<PageList<Json>>;
+    exists(id: Id, options?: RouteOptions): Promise<boolean>;
+    add(item: Json, options?: RouteOptions): Promise<Json>;
+    filter(options?: RouteOptions): Promise<PageList<Json>>;
+    update(item: Json, options?: RouteOptions): Promise<Json>;
+    upsert(item: Json, options?: RouteOptions): Promise<Json>;
+    remove(id: Id, options?: RouteOptions): Promise<boolean>;
+}
+
+declare class MappedRouteGateway extends RouteGateway {
+    readonly route: Func$1<Uri>;
+    readonly routeId: Func$1<Uri>;
+    readonly map: Mapper;
+    readonly api: Api;
+    constructor(route: Func$1<Uri>, routeId: Func$1<Uri>, map?: Mapper, api?: Api);
+    get(uri: Uri, options?: RequestOptions): Promise<PageList<Json>>;
+    getOne(uri: Uri, options?: RequestOptions): Promise<Optional<Json>>;
+    add(item: Json): Promise<Json>;
+    update(item: Json): Promise<Json>;
+}
+
+declare class ViewRouteGateway extends RouteGateway {
+    readonly route: Func$1<Uri>;
+    readonly routeId: Func$1<Uri>;
+    readonly views: {
+        in: View<Json>;
+        out: View<Json>;
+    };
+    readonly api: Api;
+    constructor(route: Func$1<Uri>, routeId: Func$1<Uri>, views?: {
+        in: View<Json>;
+        out: View<Json>;
+    }, api?: Api);
+    get(uri: Uri, options?: RequestOptions): Promise<PageList<Json>>;
+    getOne(uri: Uri, options?: RequestOptions): Promise<Optional<Json>>;
+    add(item: Json): Promise<Json>;
+    update(item: Json): Promise<Json>;
+}
+
+interface SignOptions {
+    audience?: Optional<OneOrMore<string>>;
+    issuer?: Optional<string>;
+}
+declare class Jwt extends Value implements Validatable {
+    get isValid(): boolean;
+    static sign: (token: Json, options?: SignOptions) => Jwt;
+    static of: (a: {
+        jwt: string;
+    }) => Jwt;
+    decode: () => Json;
+    toJSON(): Json;
+}
+
+declare const quote: (a: unknown) => string;
+declare class Clause implements Text {
+    readonly first: unknown;
+    readonly operator: string;
+    readonly second: unknown;
+    constructor(first: unknown, operator: string, second: unknown);
+    and: (other: Clause) => Clause;
+    or: (other: Clause) => Clause;
+    toString(): string;
+}
+declare class ParathesizedClause extends Clause {
+    toString(): string;
+}
+declare const toClause: (first: unknown, operator: string, second: unknown, conv?: Convert) => Clause;
+declare const isClause: TypeGuard<Clause>;
+
+declare class Join {
+    private first;
+    private second;
+    private c?;
+    private c2?;
+    readonly db: Database;
+    constructor(first: Table, second: Table, c?: Column | undefined, c2?: Column | undefined);
+    on(c: Column, c2: Column): this;
+    toString(): string;
+}
+
+declare class SqlQuery implements Query {
+    protected table: Table | Join;
+    readonly clauses: List<Clause>;
+    constructor(table: Table | Join, clauses?: List<Clause>);
+    where: (...clauses: Clause[]) => this;
+}
+
+declare class Select extends SqlQuery {
+    readonly columns: List<Column>;
+    protected ordered: List<OrderColumn>;
+    protected grouped: List<Column>;
+    protected _top: number;
+    protected _limit: number;
+    protected _offset: number;
+    constructor(table: Table | Join, columns?: List<Column>);
+    from(t?: Table | Join): this;
+    orderBy: (...ordered: OrderColumn[]) => this;
+    groupBy(...grouped: Column[]): this;
+    top(t: number): this;
+    limit(l: number): this;
+    offset(o: number): this;
+    toString(): string;
+}
+
+declare class Insert extends SqlQuery {
+    protected table: Table;
+    protected fields: Json;
+    constructor(table: Table, fields: Json);
+    toString(): string;
+}
+
+declare class Update extends SqlQuery {
+    protected table: Table;
+    protected fields: Json;
+    constructor(table: Table, fields: Json);
+    toString(): string;
+}
+
+declare class Delete extends SqlQuery {
+    toString(): string;
+}
+
+declare class Count extends Select {
+    constructor(table: Table | Join);
+    toString(): string;
+}
+
+declare class Table extends Mapper {
+    protected readonly map: {
+        column: <T = unknown>(name: string, options?: PropertyOptions<T> | undefined) => Column;
+        item: (property: string, options?: PropertyOptions | undefined) => Property<unknown>;
+        ignore: (property?: string) => Mapping;
+        skipIn: (property: string) => Mapping;
+        skipOut: (property: string) => Mapping;
+        func: (property: string, funcIn: Get<Optional<JsonValue>, Json>, funcOut: Get<Optional<JsonValue>, Json>) => Mapping;
+        add: (funcIn: Get<JsonValue, Json>) => Mapping;
+        map: (mapper: Construct<Mapper>, property?: string) => Mapping;
+        propsToList: (...maps: Mapping[]) => Mapping;
+        list: (mapper: Mapping, property: string) => Mapping;
+    };
+    readonly id: Column;
+    constructor(options?: MapOptions);
+    get db(): Database;
+    get count(): Count;
+    prop: <T = unknown>(name: string, options?: PropertyOptions<T> | undefined) => Column;
+    select: (...columns: Column[]) => Select;
+    insert: (fields: Json) => Insert;
+    update: (fields: Json) => Update;
+    delete: () => Delete;
+    readonly join: (t: Table) => Join;
+}
+
+declare class Column extends Property implements Text {
+    readonly owner: Table;
+    constructor(owner: Table, property: string, options?: PropertyOptions);
+    get count(): Column;
+    get max(): Column;
+    get min(): Column;
+    get sum(): Column;
+    get average(): Column;
+    get length(): Column;
+    get asc(): OrderColumn;
+    get desc(): OrderColumn;
+    in: (source?: Json) => JsonValue;
+    out: (source?: Json, key?: string) => JsonValue;
+    function: (func: string) => Column;
+    format: (pattern: string) => Column;
+    is: (value: unknown) => Clause;
+    not: (value: unknown) => Clause;
+    like: (value: unknown) => Clause;
+    startsLike: (value: unknown) => Clause;
+    endsLike: (value: unknown) => Clause;
+    unlike: (value: unknown) => Clause;
+    less: (value: unknown) => Clause;
+    lessEqual: (value: unknown) => Clause;
+    greater: (value: unknown) => Clause;
+    greaterEqual: (value: unknown) => Clause;
+    as: (as: string) => Column;
+    toString(): string;
+    protected clause: (operator: string, value: unknown) => Clause;
+}
+declare class PatternColumn extends Column {
+    protected col: Column;
+    protected pattern: string;
+    constructor(col: Column, pattern: string);
+    toString(): string;
+}
+declare class OrderColumn extends PatternColumn {
+}
+
+type TableOptions = PageOptions & {
+    provider?: QueryProvider;
+};
+declare class TableGateway<T extends Table> extends Gateway<PageOptions> {
+    readonly table: T;
+    readonly provider: QueryProvider;
+    constructor(table: T, provider?: QueryProvider);
+    protected provide: ({ provider }?: TableOptions) => QueryProvider;
+    all(options?: TableOptions): Promise<PageList<Json>>;
+    byId(id: Id, options?: TableOptions): Promise<Optional<Json>>;
+    exists(id: Id, options?: TableOptions): Promise<boolean>;
+    add(item: Json, options?: TableOptions): Promise<Json>;
+    remove(id: Id, options?: TableOptions): Promise<boolean>;
+    update(item: Json, options?: TableOptions): Promise<Json>;
+}
+
+type Constraint = Func$1<boolean | Results, any>;
+declare const constraint: <T>(c: Constraint, message: Text) => PropertyDecorator;
+declare const defined: (message?: Text) => PropertyDecorator;
+declare const required: (message?: Text) => PropertyDecorator;
+declare const notEmpty: (message?: Text) => PropertyDecorator;
+declare const valid: () => PropertyDecorator;
+declare const optional: () => PropertyDecorator;
+declare const includes: (sub: string, message?: string) => PropertyDecorator;
+declare const inList: (values: unknown[], message?: Text) => PropertyDecorator;
+declare const gt: (limit: number, message?: Text) => PropertyDecorator;
+declare const gte: (limit: number, message?: Text) => PropertyDecorator;
+declare const lt: (limit: number, message?: Text) => PropertyDecorator;
+declare const lte: (limit: number, message?: Text) => PropertyDecorator;
+declare const past: (message?: Text) => PropertyDecorator;
+declare const future: (message?: Text) => PropertyDecorator;
+declare const minLength: (length: number, message?: Text) => PropertyDecorator;
+declare const maxLength: (length: number, message?: Text) => PropertyDecorator;
+declare const rule: (message?: Text) => PropertyDecorator;
+
+type Validator = {
+    property: string | symbol;
+    constraint: Constraint;
+    text: Text;
+    actual?: Text;
+};
+declare const asResults: (subject: unknown, template: Text, options?: TemplateOptions) => Results;
+declare const validate: (subject?: unknown) => Results;
+declare const validateReject: <T>(subject: T) => Promise<T>;
+
+declare class When<W> {
+    readonly subject: W;
+    readonly valid: boolean;
+    private results?;
+    constructor(subject: W, valid?: boolean, results?: Results | undefined);
+    get not(): When<W>;
+    get and(): When<W>;
+    get isDefined(): When<W>;
+    get isEmpty(): When<W>;
+    get isTrue(): When<W>;
+    get isValid(): When<W>;
+    isInstance: <U>(c: Constructor<U>) => When<W>;
+    with: (pred: Predicate<W>) => When<W>;
+    contains: (property: (w: W) => unknown) => When<W>;
+    in: (...items: W[]) => When<W>;
+    is: (item: W) => When<W>;
+    reject: (error?: Get<ErrorOrigin, W>) => Promise<NonNullable<W>>;
+    recover: (f: (item: W) => W | Promise<W>) => Promise<W>;
+    protected clone: (result?: boolean) => When<W>;
+}
+declare const when: <T>(subject: T) => When<T>;
+
+export { Address, Api, ApiGateway, App, AppProvider, ArrayLike, Audit, AxiosProvider, BaseContext, BaseRequestContext, Box, CacheAge, CacheControl, CacheOptions, Child, Clause, Code, Column, Condition, Constraint, Construct, Constructor, ContentType, Context, Contexts, Convert, Country, Currency, DataProvider, Database, DatabaseOptions, DateTime, DateTimeUnit, DefaultProvider, Delete, DiffOptions, Dimension, DontInfer, DotEnvContext, EAN, EasyUri, Email, Endpoint, Entity, Enum, EnvContext, Environment, ErrorOrigin, Exception, FetchOptions, Field, Filter, FilterValue, Func$1 as Func, Gateway, Get, GetProperty, Handler, HasId, HealthResource, HealthUri, HttpHeader, HttpStatus, HttpVerb, IBAN, Id, Identity, InMemoryGateway, Insert, Join, Json, JsonValue, Jwt, Key, List, Locale, LogicalCondition, Manage, MapOptions, MapStartFrom, MappedRouteGateway, Mapper, Mapping, Message, Money, Name, Nullish, OneOrMore, Optional, OrderColumn, OriginatedError, PageList, PageListOptions, PageOptions, ParathesizedClause, PartialRecord, PatternColumn, PlainSort, PostalCode, Predicate, Primitive, Property, PropertyOptions, Query, QueryProvider, Repo, RepoAction, Repository, Req, Request, RequestContext, RequestOptions, RequestProvider, RequireAtLeastOne, Requires, Resource, Response, RestResult, Result, Results, Route, RouteGateway, RouteOptions, RouteRequires, Routes, Scope, Search, Segment, Select, Sentence, Service, Sort, SortCondition, SortDirection, SqlQuery, State, Store, Struct, Table, TableGateway, TableOptions, TemplateOptions, Text, ToText, Try, TypeGuard, Typo, UnitOfMeasurement, UnitOfWeight, Update, Uri, UriExpandProps, Url, UrlOptions, UseCase, Uuid, Validatable, Validator, Value, Verb$1 as Verb, VerbOptions, View, ViewRouteGateway, Wait, Weight, When, any, api, array, asJson, asList, asNumber, asPageList, asResults, asString, asc, build, cache, cacheAge, choose, constraint, convert, ctx, days, defined, del, desc, dt, email, entries, future, get, gt, gte, ifA, ifDefined, ifFalse, ifGet, ifNotEmpty, ifTrue, inFuture, inList, inPast, includes, isA, isAddress, isAn, isArray, isBoolean, isClause, isConstructor, isDate, isDateTime, isDefined, isDoesNotExist, isEAN, isEmail, isEmpty, isEmptyObject, isEnum, isEqual, isError, isException, isFalsy, isField, isFunc, isFunction, isHttpStatus, isIBAN, isIn, isInstance, isIntersecting, isIsoDateString, isJson, isList, isLoading, isMapping, isMoney, isNotEmpty, isNotPresent, isNullish, isNumber, isObject, isOriginatedError, isPageList, isPresent, isPrimitive, isRequestOptions, isResponse, isRestResult, isResult, isResults, isSimpleView, isSortCondition, isString, isStruct, isText, isTrue, isTruthy, isUndefined, isUrl, isUuid, isValidatable, isValue, json, kebab, log, lt, lte, mappings, maxLength, meta, minLength, money, name, notEmpty, ofConstruct, ofGet, ofMessage, ofProperty, on, optional, past, patch, post, postalCode, put, quote, reject, replaceAll, required, requires, resolve, rest, route, routes, rule, search, searchable, singleton, stream, tag, template, text, toArray, toCacheOptions, toClause, toCondition, toFilter, toHttpStatus, toId, toJson, toList, toName, toObject, toOriginatedError, toPageList, toPageOptions, toReq, toResponse, toResult, toResults, toSegment, toShortFilter, toUuid, toVerbOptions, toViewer, traverse, tryTo, tuple, tuple2, tuple3, tuple4, tuple5, uri, url, use, valid, validate, validateReject, view, views, wait, we, weight, when };