likec4 1.26.2 → 1.27.1

package/dist/shared/likec4.DGrST4wG.d.mts

@@ -1,2064 +0,0 @@
-import * as c4 from '@likec4/core';
-import { Fqn, EdgeId, ComputedView, DiagramView, OverviewGraph, LikeC4Model, ViewId, ProjectId, NonEmptyArray } from '@likec4/core';
-import { Tagged } from 'type-fest';
-
-/**
- * Defines an unsigned integer in the range of 0 to 2^31 - 1.
- */
-type uinteger = number;
-declare namespace uinteger {
-    const MIN_VALUE = 0;
-    const MAX_VALUE = 2147483647;
-    function is(value: any): value is uinteger;
-}
-/**
- * Position in a text document expressed as zero-based line and character
- * offset. Prior to 3.17 the offsets were always based on a UTF-16 string
- * representation. So a string of the form `a𐐀b` the character offset of the
- * character `a` is 0, the character offset of `𐐀` is 1 and the character
- * offset of b is 3 since `𐐀` is represented using two code units in UTF-16.
- * Since 3.17 clients and servers can agree on a different string encoding
- * representation (e.g. UTF-8). The client announces it's supported encoding
- * via the client capability [`general.positionEncodings`](https://microsoft.github.io/language-server-protocol/specifications/specification-current/#clientCapabilities).
- * The value is an array of position encodings the client supports, with
- * decreasing preference (e.g. the encoding at index `0` is the most preferred
- * one). To stay backwards compatible the only mandatory encoding is UTF-16
- * represented via the string `utf-16`. The server can pick one of the
- * encodings offered by the client and signals that encoding back to the
- * client via the initialize result's property
- * [`capabilities.positionEncoding`](https://microsoft.github.io/language-server-protocol/specifications/specification-current/#serverCapabilities). If the string value
- * `utf-16` is missing from the client's capability `general.positionEncodings`
- * servers can safely assume that the client supports UTF-16. If the server
- * omits the position encoding in its initialize result the encoding defaults
- * to the string value `utf-16`. Implementation considerations: since the
- * conversion from one encoding into another requires the content of the
- * file / line the conversion is best done where the file is read which is
- * usually on the server side.
- *
- * Positions are line end character agnostic. So you can not specify a position
- * that denotes `\r|\n` or `\n|` where `|` represents the character offset.
- *
- * @since 3.17.0 - support for negotiated position encoding.
- */
-interface Position {
-    /**
-     * Line position in a document (zero-based).
-     *
-     * If a line number is greater than the number of lines in a document, it defaults back to the number of lines in the document.
-     * If a line number is negative, it defaults to 0.
-     */
-    line: uinteger;
-    /**
-     * Character offset on a line in a document (zero-based).
-     *
-     * The meaning of this offset is determined by the negotiated
-     * `PositionEncodingKind`.
-     *
-     * If the character value is greater than the line length it defaults back to the
-     * line length.
-     */
-    character: uinteger;
-}
-/**
- * The Position namespace provides helper functions to work with
- * {@link Position} literals.
- */
-declare namespace Position {
-    /**
-     * Creates a new Position literal from the given line and character.
-     * @param line The position's line.
-     * @param character The position's character.
-     */
-    function create(line: uinteger, character: uinteger): Position;
-    /**
-     * Checks whether the given literal conforms to the {@link Position} interface.
-     */
-    function is(value: any): value is Position;
-}
-/**
- * A range in a text document expressed as (zero-based) start and end positions.
- *
- * If you want to specify a range that contains a line including the line ending
- * character(s) then use an end position denoting the start of the next line.
- * For example:
- * ```ts
- * {
- *     start: { line: 5, character: 23 }
- *     end : { line 6, character : 0 }
- * }
- * ```
- */
-interface Range {
-    /**
-     * The range's start position.
-     */
-    start: Position;
-    /**
-     * The range's end position.
-     */
-    end: Position;
-}
-/**
- * The Range namespace provides helper functions to work with
- * {@link Range} literals.
- */
-declare namespace Range {
-    /**
-     * Create a new Range literal.
-     * @param start The range's start position.
-     * @param end The range's end position.
-     */
-    function create(start: Position, end: Position): Range;
-    /**
-     * Create a new Range literal.
-     * @param startLine The start line number.
-     * @param startCharacter The start character.
-     * @param endLine The end line number.
-     * @param endCharacter The end character.
-     */
-    function create(startLine: uinteger, startCharacter: uinteger, endLine: uinteger, endCharacter: uinteger): Range;
-    /**
-     * Checks whether the given literal conforms to the {@link Range} interface.
-     */
-    function is(value: any): value is Range;
-}
-
-/**
- * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.
- * This class is a simple parser which creates the basic component parts
- * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation
- * and encoding.
- *
- * ```txt
- *       foo://example.com:8042/over/there?name=ferret#nose
- *       \_/   \______________/\_________/ \_________/ \__/
- *        |           |            |            |        |
- *     scheme     authority       path        query   fragment
- *        |   _____________________|__
- *       / \ /                        \
- *       urn:example:animal:ferret:nose
- * ```
- */
-declare class URI implements UriComponents {
-    static isUri(thing: any): thing is URI;
-    /**
-     * scheme is the 'http' part of 'http://www.example.com/some/path?query#fragment'.
-     * The part before the first colon.
-     */
-    readonly scheme: string;
-    /**
-     * authority is the 'www.example.com' part of 'http://www.example.com/some/path?query#fragment'.
-     * The part between the first double slashes and the next slash.
-     */
-    readonly authority: string;
-    /**
-     * path is the '/some/path' part of 'http://www.example.com/some/path?query#fragment'.
-     */
-    readonly path: string;
-    /**
-     * query is the 'query' part of 'http://www.example.com/some/path?query#fragment'.
-     */
-    readonly query: string;
-    /**
-     * fragment is the 'fragment' part of 'http://www.example.com/some/path?query#fragment'.
-     */
-    readonly fragment: string;
-    /**
-     * @internal
-     */
-    protected constructor(scheme: string, authority?: string, path?: string, query?: string, fragment?: string, _strict?: boolean);
-    /**
-     * @internal
-     */
-    protected constructor(components: UriComponents);
-    /**
-     * Returns a string representing the corresponding file system path of this URI.
-     * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the
-     * platform specific path separator.
-     *
-     * * Will *not* validate the path for invalid characters and semantics.
-     * * Will *not* look at the scheme of this URI.
-     * * The result shall *not* be used for display purposes but for accessing a file on disk.
-     *
-     *
-     * The *difference* to `URI#path` is the use of the platform specific separator and the handling
-     * of UNC paths. See the below sample of a file-uri with an authority (UNC path).
-     *
-     * ```ts
-        const u = URI.parse('file://server/c$/folder/file.txt')
-        u.authority === 'server'
-        u.path === '/shares/c$/file.txt'
-        u.fsPath === '\\server\c$\folder\file.txt'
-    ```
-     *
-     * Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path,
-     * namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working
-     * with URIs that represent files on disk (`file` scheme).
-     */
-    get fsPath(): string;
-    with(change: {
-        scheme?: string;
-        authority?: string | null;
-        path?: string | null;
-        query?: string | null;
-        fragment?: string | null;
-    }): URI;
-    /**
-     * Creates a new URI from a string, e.g. `http://www.example.com/some/path`,
-     * `file:///usr/home`, or `scheme:with/path`.
-     *
-     * @param value A string which represents an URI (see `URI#toString`).
-     */
-    static parse(value: string, _strict?: boolean): URI;
-    /**
-     * Creates a new URI from a file system path, e.g. `c:\my\files`,
-     * `/usr/home`, or `\\server\share\some\path`.
-     *
-     * The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument
-     * as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as**
-     * `URI.parse('file://' + path)` because the path might contain characters that are
-     * interpreted (# and ?). See the following sample:
-     * ```ts
-    const good = URI.file('/coding/c#/project1');
-    good.scheme === 'file';
-    good.path === '/coding/c#/project1';
-    good.fragment === '';
-    const bad = URI.parse('file://' + '/coding/c#/project1');
-    bad.scheme === 'file';
-    bad.path === '/coding/c'; // path is now broken
-    bad.fragment === '/project1';
-    ```
-     *
-     * @param path A file system path (see `URI#fsPath`)
-     */
-    static file(path: string): URI;
-    static from(components: {
-        scheme: string;
-        authority?: string;
-        path?: string;
-        query?: string;
-        fragment?: string;
-    }): URI;
-    /**
-     * Creates a string representation for this URI. It's guaranteed that calling
-     * `URI.parse` with the result of this function creates an URI which is equal
-     * to this URI.
-     *
-     * * The result shall *not* be used for display purposes but for externalization or transport.
-     * * The result will be encoded using the percentage encoding and encoding happens mostly
-     * ignore the scheme-specific encoding rules.
-     *
-     * @param skipEncoding Do not encode the result, default is `false`
-     */
-    toString(skipEncoding?: boolean): string;
-    toJSON(): UriComponents;
-    static revive(data: UriComponents | URI): URI;
-    static revive(data: UriComponents | URI | undefined): URI | undefined;
-    static revive(data: UriComponents | URI | null): URI | null;
-    static revive(data: UriComponents | URI | undefined | null): URI | undefined | null;
-}
-interface UriComponents {
-    scheme: string;
-    authority: string;
-    path: string;
-    query: string;
-    fragment: string;
-}
-
-interface Disposable$1 {
-    /**
-     * Dispose this object.
-     */
-    dispose(): void;
-}
-declare namespace Disposable$1 {
-    function create(func: () => void): Disposable$1;
-}
-
-/**
- * Represents a typed event.
- */
-interface Event<T> {
-    /**
-     *
-     * @param listener The listener function will be called when the event happens.
-     * @param thisArgs The 'this' which will be used when calling the event listener.
-     * @param disposables An array to which a {{IDisposable}} will be added.
-     * @return
-    */
-    (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable$1[]): Disposable$1;
-}
-declare namespace Event {
-    const None: Event<any>;
-}
-
-/**
- * Defines a CancellationToken. This interface is not
- * intended to be implemented. A CancellationToken must
- * be created via a CancellationTokenSource.
- */
-interface CancellationToken {
-    /**
-     * Is `true` when the token has been cancelled, `false` otherwise.
-     */
-    readonly isCancellationRequested: boolean;
-    /**
-     * An {@link Event event} which fires upon cancellation.
-     */
-    readonly onCancellationRequested: Event<any>;
-}
-declare namespace CancellationToken {
-    const None: CancellationToken;
-    const Cancelled: CancellationToken;
-    function is(value: any): value is CancellationToken;
-}
-
-interface AsyncDisposable {
-    /**
-     * Dispose this object.
-     */
-    dispose(): Promise<void>;
-}
-/******************************************************************************
- * Copyright 2021 TypeFox GmbH
- * This program and the accompanying materials are made available under the
- * terms of the MIT License, which is available in the project root.
- ******************************************************************************/
-interface Disposable {
-    /**
-     * Dispose this object.
-     */
-    dispose(): void;
-}
-declare namespace Disposable {
-    function create(callback: () => Promise<void>): AsyncDisposable;
-    function create(callback: () => void): Disposable;
-}
-
-/**
- * @hidden
- */
-type $keywords<T extends string> = {
-  [key in T]: key;
-};
-
-declare module 'ts-graphviz' {
-    namespace ClusterSubgraphAttributeKey {
-        interface $values extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_level' | 'likec4_depth'> {
-        }
-    }
-    namespace NodeAttributeKey {
-        interface $values extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_level'> {
-        }
-    }
-    namespace EdgeAttributeKey {
-        interface $values extends $keywords<'likec4_id'> {
-        }
-    }
-    namespace Attribute {
-        interface $keys extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_level' | 'likec4_depth'> {
-        }
-        interface $types {
-            likec4_type: 'folder' | 'file' | 'view';
-            likec4_path: string;
-            likec4_id: string;
-            likec4_level: number;
-            likec4_depth: number;
-        }
-    }
-}
-type DotSource = Tagged<string, 'DotSource'>;
-
-type GvNodeName = Tagged<string, 'GvNodeName'>;
-type GvId = Tagged<number, 'GvId'>;
-type Point = [x: number, y: number];
-interface GraphvizJson {
-    name: GvNodeName;
-    directed: boolean;
-    strict: boolean;
-    _draw_: GraphvizJson.Draw[];
-    bb: string;
-    compound: string;
-    fontname: string;
-    fontsize: string;
-    label: string;
-    nodesep: string;
-    outputorder: string;
-    rankdir: string;
-    ranksep: string;
-    splines: string;
-    xdotversion: string;
-    _subgraph_cnt: number;
-    objects?: GraphvizJson.GvObject[];
-    edges?: GraphvizJson.Edge[];
-}
-declare namespace GraphvizJson {
-    interface Draw {
-        op: string;
-        grad: string;
-        color: string;
-        points: Point[];
-    }
-    interface Draw2 {
-        op: string;
-        grad: string;
-        color: string;
-        points: Point[];
-    }
-    namespace DrawOps {
-        type Style = {
-            op: 'S';
-            style: string;
-        };
-        type BSpline = {
-            op: 'b' | 'B';
-            points: Point[];
-        };
-        type Color = {
-            op: 'c';
-            grad: string;
-            color: string;
-        };
-        type Polygon = {
-            op: 'p' | 'P';
-            points: Point[];
-        };
-    }
-    type DrawOp = DrawOps.Style | DrawOps.BSpline | DrawOps.Color | DrawOps.Polygon;
-    type LabelDrawOps = {
-        op: 'F';
-        size: number;
-        face: string;
-    } | {
-        op: 'c';
-        color: string;
-    } | {
-        op: 't';
-        fontchar: number;
-    } | {
-        op: 'T';
-        pt: Point;
-        align: 'l' | 'r' | 'c';
-        width: number;
-        text: string;
-    };
-    type GvObject = GvNodeObject | GvSubgraph;
-    interface GvSubgraph {
-        bb: string;
-        label?: string;
-        compound: 'true';
-        _ldraw_?: LabelDrawOps[];
-        likec4_type?: 'folder' | 'file';
-        likec4_path?: string;
-        likec4_id?: Fqn;
-        likec4_level?: number;
-        likec4_depth?: number;
-        _gvid: GvId;
-        subgraphs?: GvId[];
-        nodes?: GvId[];
-        edges?: GvId[];
-    }
-    interface GvNodeObject {
-        _draw_: Draw[];
-        _ldraw_?: LabelDrawOps[];
-        likec4_type?: 'folder' | 'file' | 'view';
-        likec4_path?: string;
-        likec4_id?: Fqn;
-        likec4_level?: number;
-        _gvid: GvId;
-        height: string;
-        pos: string;
-        shape: 'rect';
-        width: string;
-        label?: string;
-    }
-    interface Draw3 {
-        op: string;
-        grad: string;
-        color: string;
-        points: Point[];
-    }
-    interface Hdraw {
-        op: string;
-        style: string;
-        grad: string;
-        color: string;
-        points: Point[];
-    }
-    interface Edge {
-        _gvid: GvId;
-        tail: GvId;
-        head: GvId;
-        dir?: 'forward' | 'back' | 'both' | 'none';
-        _draw_: DrawOp[];
-        _hdraw_?: DrawOp[];
-        _tdraw_?: DrawOp[];
-        _ldraw_?: LabelDrawOps[];
-        _tldraw_?: LabelDrawOps[];
-        _hldraw_?: LabelDrawOps[];
-        fontname: string;
-        fontsize: string;
-        likec4_id?: EdgeId;
-        label: string;
-        lp: string;
-        nojustify?: 'true' | 'false';
-        pos?: string;
-    }
-}
-
-interface GraphvizPort {
-    unflatten(dot: DotSource): Promise<DotSource>;
-    acyclic(dot: DotSource): Promise<DotSource>;
-    layoutJson(dot: DotSource): Promise<string>;
-    svg(dot: DotSource): Promise<string>;
-}
-type LayoutResult = {
-    dot: DotSource;
-    diagram: DiagramView;
-};
-declare class GraphvizLayouter {
-    private graphviz;
-    constructor(graphviz: GraphvizPort);
-    get port(): GraphvizPort;
-    changePort(graphviz: GraphvizPort): void;
-    dotToJson(dot: DotSource): Promise<GraphvizJson>;
-    layout(view: ComputedView): Promise<LayoutResult>;
-    svg(view: ComputedView): Promise<{
-        svg: string;
-        dot: DotSource;
-    }>;
-    dot(computedView: ComputedView): Promise<DotSource>;
-    layoutOverviewGraph(views: ComputedView[]): Promise<OverviewGraph>;
-}
-
-/**
- * Fallback type.
- */
-type Fallback<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>> = MaybeReadonly<InferOutput<TSchema>> | ((dataset?: OutputDataset<InferOutput<TSchema>, InferIssue<TSchema>>, config?: Config<InferIssue<TSchema>>) => MaybeReadonly<InferOutput<TSchema>>);
-/**
- * Schema with fallback type.
- */
-type SchemaWithFallback<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TFallback extends Fallback<TSchema>> = TSchema & {
-    /**
-     * The fallback value.
-     */
-    readonly fallback: TFallback;
-};
-
-/**
- * Fallback async type.
- */
-type FallbackAsync<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> = MaybeReadonly<InferOutput<TSchema>> | ((dataset?: OutputDataset<InferOutput<TSchema>, InferIssue<TSchema>>, config?: Config<InferIssue<TSchema>>) => MaybePromise<MaybeReadonly<InferOutput<TSchema>>>);
-/**
- * Schema with fallback async type.
- */
-type SchemaWithFallbackAsync<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TFallback extends FallbackAsync<TSchema>> = Omit<TSchema, 'async' | '~standard' | '~run'> & {
-    /**
-     * The fallback value.
-     */
-    readonly fallback: TFallback;
-    /**
-     * Whether it's async.
-     */
-    readonly async: true;
-    /**
-     * The Standard Schema properties.
-     *
-     * @internal
-     */
-    readonly '~standard': StandardProps<InferInput<TSchema>, InferOutput<TSchema>>;
-    /**
-     * Parses unknown input values.
-     *
-     * @param dataset The input dataset.
-     * @param config The configuration.
-     *
-     * @returns The output dataset.
-     *
-     * @internal
-     */
-    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<InferOutput<TSchema>, InferIssue<TSchema>>>;
-};
-
-/**
- * Schema with pipe type.
- */
-type SchemaWithPipe<TPipe extends [
-    BaseSchema<unknown, unknown, BaseIssue<unknown>>,
-    ...PipeItem<any, unknown, BaseIssue<unknown>>[]
-]> = Omit<FirstTupleItem<TPipe>, '~standard' | '~run' | '~types'> & {
-    /**
-     * The pipe items.
-     */
-    readonly pipe: TPipe;
-    /**
-     * The Standard Schema properties.
-     *
-     * @internal
-     */
-    readonly '~standard': StandardProps<InferInput<FirstTupleItem<TPipe>>, InferOutput<LastTupleItem<TPipe>>>;
-    /**
-     * Parses unknown input values.
-     *
-     * @param dataset The input dataset.
-     * @param config The configuration.
-     *
-     * @returns The output dataset.
-     *
-     * @internal
-     */
-    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => OutputDataset<InferOutput<LastTupleItem<TPipe>>, InferIssue<TPipe[number]>>;
-    /**
-     * The input, output and issue type.
-     *
-     * @internal
-     */
-    readonly '~types'?: {
-        readonly input: InferInput<FirstTupleItem<TPipe>>;
-        readonly output: InferOutput<LastTupleItem<TPipe>>;
-        readonly issue: InferIssue<TPipe[number]>;
-    } | undefined;
-};
-
-/**
- * Schema with pipe async type.
- */
-type SchemaWithPipeAsync<TPipe extends [
-    (BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>),
-    ...(PipeItem<any, unknown, BaseIssue<unknown>> | PipeItemAsync<any, unknown, BaseIssue<unknown>>)[]
-]> = Omit<FirstTupleItem<TPipe>, 'async' | '~standard' | '~run' | '~types'> & {
-    /**
-     * The pipe items.
-     */
-    readonly pipe: TPipe;
-    /**
-     * Whether it's async.
-     */
-    readonly async: true;
-    /**
-     * The Standard Schema properties.
-     *
-     * @internal
-     */
-    readonly '~standard': StandardProps<InferInput<FirstTupleItem<TPipe>>, InferOutput<LastTupleItem<TPipe>>>;
-    /**
-     * Parses unknown input values.
-     *
-     * @param dataset The input dataset.
-     * @param config The configuration.
-     *
-     * @returns The output dataset.
-     *
-     * @internal
-     */
-    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<InferOutput<LastTupleItem<TPipe>>, InferIssue<TPipe[number]>>>;
-    /**
-     * The input, output and issue type.
-     *
-     * @internal
-     */
-    readonly '~types'?: {
-        readonly input: InferInput<FirstTupleItem<TPipe>>;
-        readonly output: InferOutput<LastTupleItem<TPipe>>;
-        readonly issue: InferIssue<TPipe[number]>;
-    } | undefined;
-};
-
-/**
- * Base metadata interface.
- */
-interface BaseMetadata<TInput> {
-    /**
-     * The object kind.
-     */
-    readonly kind: 'metadata';
-    /**
-     * The metadata type.
-     */
-    readonly type: string;
-    /**
-     * The metadata reference.
-     */
-    readonly reference: (...args: any[]) => BaseMetadata<any>;
-    /**
-     * The input, output and issue type.
-     *
-     * @internal
-     */
-    readonly '~types'?: {
-        readonly input: TInput;
-        readonly output: TInput;
-        readonly issue: never;
-    } | undefined;
-}
-
-/**
- * Unknown dataset interface.
- */
-interface UnknownDataset {
-    /**
-     * Whether is's typed.
-     */
-    typed?: false;
-    /**
-     * The dataset value.
-     */
-    value: unknown;
-    /**
-     * The dataset issues.
-     */
-    issues?: undefined;
-}
-/**
- * Success dataset interface.
- */
-interface SuccessDataset<TValue> {
-    /**
-     * Whether is's typed.
-     */
-    typed: true;
-    /**
-     * The dataset value.
-     */
-    value: TValue;
-    /**
-     * The dataset issues.
-     */
-    issues?: undefined;
-}
-/**
- * Partial dataset interface.
- */
-interface PartialDataset<TValue, TIssue extends BaseIssue<unknown>> {
-    /**
-     * Whether is's typed.
-     */
-    typed: true;
-    /**
-     * The dataset value.
-     */
-    value: TValue;
-    /**
-     * The dataset issues.
-     */
-    issues: [TIssue, ...TIssue[]];
-}
-/**
- * Failure dataset interface.
- */
-interface FailureDataset<TIssue extends BaseIssue<unknown>> {
-    /**
-     * Whether is's typed.
-     */
-    typed: false;
-    /**
-     * The dataset value.
-     */
-    value: unknown;
-    /**
-     * The dataset issues.
-     */
-    issues: [TIssue, ...TIssue[]];
-}
-/**
- * Output dataset type.
- */
-type OutputDataset<TValue, TIssue extends BaseIssue<unknown>> = SuccessDataset<TValue> | PartialDataset<TValue, TIssue> | FailureDataset<TIssue>;
-
-/**
- * The Standard Schema properties interface.
- */
-interface StandardProps<TInput, TOutput> {
-    /**
-     * The version number of the standard.
-     */
-    readonly version: 1;
-    /**
-     * The vendor name of the schema library.
-     */
-    readonly vendor: 'valibot';
-    /**
-     * Validates unknown input values.
-     */
-    readonly validate: (value: unknown) => StandardResult<TOutput> | Promise<StandardResult<TOutput>>;
-    /**
-     * Inferred types associated with the schema.
-     */
-    readonly types?: StandardTypes<TInput, TOutput> | undefined;
-}
-/**
- * The result interface of the validate function.
- */
-type StandardResult<TOutput> = StandardSuccessResult<TOutput> | StandardFailureResult;
-/**
- * The result interface if validation succeeds.
- */
-interface StandardSuccessResult<TOutput> {
-    /**
-     * The typed output value.
-     */
-    readonly value: TOutput;
-    /**
-     * The non-existent issues.
-     */
-    readonly issues?: undefined;
-}
-/**
- * The result interface if validation fails.
- */
-interface StandardFailureResult {
-    /**
-     * The issues of failed validation.
-     */
-    readonly issues: readonly StandardIssue[];
-}
-/**
- * The issue interface of the failure output.
- */
-interface StandardIssue {
-    /**
-     * The error message of the issue.
-     */
-    readonly message: string;
-    /**
-     * The path of the issue, if any.
-     */
-    readonly path?: readonly (PropertyKey | StandardPathItem)[] | undefined;
-}
-/**
- * The path item interface of the issue.
- */
-interface StandardPathItem {
-    /**
-     * The key of the path item.
-     */
-    readonly key: PropertyKey;
-}
-/**
- * The Standard Schema types interface.
- */
-interface StandardTypes<TInput, TOutput> {
-    /**
-     * The input type of the schema.
-     */
-    readonly input: TInput;
-    /**
-     * The output type of the schema.
-     */
-    readonly output: TOutput;
-}
-
-/**
- * Base schema interface.
- */
-interface BaseSchema<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
-    /**
-     * The object kind.
-     */
-    readonly kind: 'schema';
-    /**
-     * The schema type.
-     */
-    readonly type: string;
-    /**
-     * The schema reference.
-     */
-    readonly reference: (...args: any[]) => BaseSchema<unknown, unknown, BaseIssue<unknown>>;
-    /**
-     * The expected property.
-     */
-    readonly expects: string;
-    /**
-     * Whether it's async.
-     */
-    readonly async: false;
-    /**
-     * The Standard Schema properties.
-     *
-     * @internal
-     */
-    readonly '~standard': StandardProps<TInput, TOutput>;
-    /**
-     * Parses unknown input values.
-     *
-     * @param dataset The input dataset.
-     * @param config The configuration.
-     *
-     * @returns The output dataset.
-     *
-     * @internal
-     */
-    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput, TIssue>;
-    /**
-     * The input, output and issue type.
-     *
-     * @internal
-     */
-    readonly '~types'?: {
-        readonly input: TInput;
-        readonly output: TOutput;
-        readonly issue: TIssue;
-    } | undefined;
-}
-/**
- * Base schema async interface.
- */
-interface BaseSchemaAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseSchema<TInput, TOutput, TIssue>, 'reference' | 'async' | '~run'> {
-    /**
-     * The schema reference.
-     */
-    readonly reference: (...args: any[]) => BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>;
-    /**
-     * Whether it's async.
-     */
-    readonly async: true;
-    /**
-     * Parses unknown input values.
-     *
-     * @param dataset The input dataset.
-     * @param config The configuration.
-     *
-     * @returns The output dataset.
-     *
-     * @internal
-     */
-    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput, TIssue>>;
-}
-
-/**
- * Base transformation interface.
- */
-interface BaseTransformation<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
-    /**
-     * The object kind.
-     */
-    readonly kind: 'transformation';
-    /**
-     * The transformation type.
-     */
-    readonly type: string;
-    /**
-     * The transformation reference.
-     */
-    readonly reference: (...args: any[]) => BaseTransformation<any, any, BaseIssue<unknown>>;
-    /**
-     * Whether it's async.
-     */
-    readonly async: false;
-    /**
-     * Transforms known input values.
-     *
-     * @param dataset The input dataset.
-     * @param config The configuration.
-     *
-     * @returns The output dataset.
-     *
-     * @internal
-     */
-    readonly '~run': (dataset: SuccessDataset<TInput>, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput, BaseIssue<unknown> | TIssue>;
-    /**
-     * The input, output and issue type.
-     *
-     * @internal
-     */
-    readonly '~types'?: {
-        readonly input: TInput;
-        readonly output: TOutput;
-        readonly issue: TIssue;
-    } | undefined;
-}
-/**
- * Base transformation async interface.
- */
-interface BaseTransformationAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseTransformation<TInput, TOutput, TIssue>, 'reference' | 'async' | '~run'> {
-    /**
-     * The transformation reference.
-     */
-    readonly reference: (...args: any[]) => BaseTransformation<any, any, BaseIssue<unknown>> | BaseTransformationAsync<any, any, BaseIssue<unknown>>;
-    /**
-     * Whether it's async.
-     */
-    readonly async: true;
-    /**
-     * Transforms known input values.
-     *
-     * @param dataset The input dataset.
-     * @param config The configuration.
-     *
-     * @returns The output dataset.
-     *
-     * @internal
-     */
-    readonly '~run': (dataset: SuccessDataset<TInput>, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput, BaseIssue<unknown> | TIssue>>;
-}
-
-/**
- * Base validation interface.
- */
-interface BaseValidation<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
-    /**
-     * The object kind.
-     */
-    readonly kind: 'validation';
-    /**
-     * The validation type.
-     */
-    readonly type: string;
-    /**
-     * The validation reference.
-     */
-    readonly reference: (...args: any[]) => BaseValidation<any, any, BaseIssue<unknown>>;
-    /**
-     * The expected property.
-     */
-    readonly expects: string | null;
-    /**
-     * Whether it's async.
-     */
-    readonly async: false;
-    /**
-     * Validates known input values.
-     *
-     * @param dataset The input dataset.
-     * @param config The configuration.
-     *
-     * @returns The output dataset.
-     *
-     * @internal
-     */
-    readonly '~run': (dataset: OutputDataset<TInput, BaseIssue<unknown>>, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput, BaseIssue<unknown> | TIssue>;
-    /**
-     * The input, output and issue type.
-     *
-     * @internal
-     */
-    readonly '~types'?: {
-        readonly input: TInput;
-        readonly output: TOutput;
-        readonly issue: TIssue;
-    } | undefined;
-}
-/**
- * Base validation async interface.
- */
-interface BaseValidationAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseValidation<TInput, TOutput, TIssue>, 'reference' | 'async' | '~run'> {
-    /**
-     * The validation reference.
-     */
-    readonly reference: (...args: any[]) => BaseValidation<any, any, BaseIssue<unknown>> | BaseValidationAsync<any, any, BaseIssue<unknown>>;
-    /**
-     * Whether it's async.
-     */
-    readonly async: true;
-    /**
-     * Validates known input values.
-     *
-     * @param dataset The input dataset.
-     * @param config The configuration.
-     *
-     * @returns The output dataset.
-     *
-     * @internal
-     */
-    readonly '~run': (dataset: OutputDataset<TInput, BaseIssue<unknown>>, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput, BaseIssue<unknown> | TIssue>>;
-}
-
-/**
- * Infer input type.
- */
-type InferInput<TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | BaseValidation<any, unknown, BaseIssue<unknown>> | BaseValidationAsync<any, unknown, BaseIssue<unknown>> | BaseTransformation<any, unknown, BaseIssue<unknown>> | BaseTransformationAsync<any, unknown, BaseIssue<unknown>> | BaseMetadata<any>> = NonNullable<TItem['~types']>['input'];
-/**
- * Infer output type.
- */
-type InferOutput<TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | BaseValidation<any, unknown, BaseIssue<unknown>> | BaseValidationAsync<any, unknown, BaseIssue<unknown>> | BaseTransformation<any, unknown, BaseIssue<unknown>> | BaseTransformationAsync<any, unknown, BaseIssue<unknown>> | BaseMetadata<any>> = NonNullable<TItem['~types']>['output'];
-/**
- * Infer issue type.
- */
-type InferIssue<TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | BaseValidation<any, unknown, BaseIssue<unknown>> | BaseValidationAsync<any, unknown, BaseIssue<unknown>> | BaseTransformation<any, unknown, BaseIssue<unknown>> | BaseTransformationAsync<any, unknown, BaseIssue<unknown>> | BaseMetadata<any>> = NonNullable<TItem['~types']>['issue'];
-/**
- * Constructs a type that is maybe readonly.
- */
-type MaybeReadonly<TValue> = TValue | Readonly<TValue>;
-/**
- * Constructs a type that is maybe a promise.
- */
-type MaybePromise<TValue> = TValue | Promise<TValue>;
-/**
- * Prettifies a type for better readability.
- *
- * Hint: This type has no effect and is only used so that TypeScript displays
- * the final type in the preview instead of the utility types used.
- */
-type Prettify<TObject> = {
-    [TKey in keyof TObject]: TObject[TKey];
-} & {};
-/**
- * Marks specific keys as optional.
- */
-type MarkOptional<TObject, TKeys extends keyof TObject> = Partial<TObject> & Required<Omit<TObject, TKeys>>;
-/**
- * Extracts first tuple item.
- */
-type FirstTupleItem<TTuple extends [unknown, ...unknown[]]> = TTuple[0];
-/**
- * Extracts last tuple item.
- */
-type LastTupleItem<TTuple extends [unknown, ...unknown[]]> = TTuple[TTuple extends [unknown, ...infer TRest] ? TRest['length'] : never];
-
-/**
- * Error message type.
- */
-type ErrorMessage<TIssue extends BaseIssue<unknown>> = ((issue: TIssue) => string) | string;
-/**
- * Default type.
- */
-type Default<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TInput extends null | undefined> = MaybeReadonly<InferInput<TWrapped> | TInput> | ((dataset?: UnknownDataset, config?: Config<InferIssue<TWrapped>>) => MaybeReadonly<InferInput<TWrapped> | TInput>) | undefined;
-/**
- * Default async type.
- */
-type DefaultAsync<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TInput extends null | undefined> = MaybeReadonly<InferInput<TWrapped> | TInput> | ((dataset?: UnknownDataset, config?: Config<InferIssue<TWrapped>>) => MaybePromise<MaybeReadonly<InferInput<TWrapped> | TInput>>) | undefined;
-/**
- * Default value type.
- */
-type DefaultValue<TDefault extends Default<BaseSchema<unknown, unknown, BaseIssue<unknown>>, null | undefined> | DefaultAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, null | undefined>> = TDefault extends DefaultAsync<infer TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, infer TInput> ? TDefault extends (dataset?: UnknownDataset, config?: Config<InferIssue<TWrapped>>) => MaybePromise<InferInput<TWrapped> | TInput> ? Awaited<ReturnType<TDefault>> : TDefault : never;
-
-/**
- * Optional entry schema type.
- */
-type OptionalEntrySchema = ExactOptionalSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | NullishSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown>;
-/**
- * Optional entry schema async type.
- */
-type OptionalEntrySchemaAsync = ExactOptionalSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown> | NullishSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown>;
-/**
- * Object entries interface.
- */
-interface ObjectEntries {
-    [key: string]: BaseSchema<unknown, unknown, BaseIssue<unknown>> | SchemaWithFallback<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalEntrySchema;
-}
-/**
- * Object entries async interface.
- */
-interface ObjectEntriesAsync {
-    [key: string]: BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | SchemaWithFallback<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | SchemaWithFallbackAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalEntrySchema | OptionalEntrySchemaAsync;
-}
-/**
- * Infer entries input type.
- */
-type InferEntriesInput<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
-    -readonly [TKey in keyof TEntries]: InferInput<TEntries[TKey]>;
-};
-/**
- * Infer entries output type.
- */
-type InferEntriesOutput<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
-    -readonly [TKey in keyof TEntries]: InferOutput<TEntries[TKey]>;
-};
-/**
- * Optional input keys type.
- */
-type OptionalInputKeys<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
-    [TKey in keyof TEntries]: TEntries[TKey] extends OptionalEntrySchema | OptionalEntrySchemaAsync ? TKey : never;
-}[keyof TEntries];
-/**
- * Optional output keys type.
- */
-type OptionalOutputKeys<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
-    [TKey in keyof TEntries]: TEntries[TKey] extends OptionalEntrySchema | OptionalEntrySchemaAsync ? undefined extends TEntries[TKey]['default'] ? TKey : never : never;
-}[keyof TEntries];
-/**
- * Input with question marks type.
- */
-type InputWithQuestionMarks<TEntries extends ObjectEntries | ObjectEntriesAsync, TObject extends InferEntriesInput<TEntries>> = MarkOptional<TObject, OptionalInputKeys<TEntries>>;
-/**
- * Output with question marks type.
- */
-type OutputWithQuestionMarks<TEntries extends ObjectEntries | ObjectEntriesAsync, TObject extends InferEntriesOutput<TEntries>> = MarkOptional<TObject, OptionalOutputKeys<TEntries>>;
-/**
- * Readonly output keys type.
- */
-type ReadonlyOutputKeys<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
-    [TKey in keyof TEntries]: TEntries[TKey] extends SchemaWithPipe<infer TPipe> | SchemaWithPipeAsync<infer TPipe> ? ReadonlyAction<any> extends TPipe[number] ? TKey : never : never;
-}[keyof TEntries];
-/**
- * Output with readonly type.
- */
-type OutputWithReadonly<TEntries extends ObjectEntries | ObjectEntriesAsync, TObject extends OutputWithQuestionMarks<TEntries, InferEntriesOutput<TEntries>>> = Readonly<TObject> & Pick<TObject, Exclude<keyof TObject, ReadonlyOutputKeys<TEntries>>>;
-/**
- * Infer object input type.
- */
-type InferObjectInput<TEntries extends ObjectEntries | ObjectEntriesAsync> = Prettify<InputWithQuestionMarks<TEntries, InferEntriesInput<TEntries>>>;
-/**
- * Infer object output type.
- */
-type InferObjectOutput<TEntries extends ObjectEntries | ObjectEntriesAsync> = Prettify<OutputWithReadonly<TEntries, OutputWithQuestionMarks<TEntries, InferEntriesOutput<TEntries>>>>;
-/**
- * Infer object issue type.
- */
-type InferObjectIssue<TEntries extends ObjectEntries | ObjectEntriesAsync> = InferIssue<TEntries[keyof TEntries]>;
-
-/**
- * Array path item interface.
- */
-interface ArrayPathItem {
-    /**
-     * The path item type.
-     */
-    readonly type: 'array';
-    /**
-     * The path item origin.
-     */
-    readonly origin: 'value';
-    /**
-     * The path item input.
-     */
-    readonly input: MaybeReadonly<unknown[]>;
-    /**
-     * The path item key.
-     */
-    readonly key: number;
-    /**
-     * The path item value.
-     */
-    readonly value: unknown;
-}
-/**
- * Map path item interface.
- */
-interface MapPathItem {
-    /**
-     * The path item type.
-     */
-    readonly type: 'map';
-    /**
-     * The path item origin.
-     */
-    readonly origin: 'key' | 'value';
-    /**
-     * The path item input.
-     */
-    readonly input: Map<unknown, unknown>;
-    /**
-     * The path item key.
-     */
-    readonly key: unknown;
-    /**
-     * The path item value.
-     */
-    readonly value: unknown;
-}
-/**
- * Object path item interface.
- */
-interface ObjectPathItem {
-    /**
-     * The path item type.
-     */
-    readonly type: 'object';
-    /**
-     * The path item origin.
-     */
-    readonly origin: 'key' | 'value';
-    /**
-     * The path item input.
-     */
-    readonly input: Record<string, unknown>;
-    /**
-     * The path item key.
-     */
-    readonly key: string;
-    /**
-     * The path item value.
-     */
-    readonly value: unknown;
-}
-/**
- * Set path item interface.
- */
-interface SetPathItem {
-    /**
-     * The path item type.
-     */
-    readonly type: 'set';
-    /**
-     * The path item origin.
-     */
-    readonly origin: 'value';
-    /**
-     * The path item input.
-     */
-    readonly input: Set<unknown>;
-    /**
-     * The path item key.
-     */
-    readonly key: null;
-    /**
-     * The path item key.
-     */
-    readonly value: unknown;
-}
-/**
- * Unknown path item interface.
- */
-interface UnknownPathItem {
-    /**
-     * The path item type.
-     */
-    readonly type: 'unknown';
-    /**
-     * The path item origin.
-     */
-    readonly origin: 'key' | 'value';
-    /**
-     * The path item input.
-     */
-    readonly input: unknown;
-    /**
-     * The path item key.
-     */
-    readonly key: unknown;
-    /**
-     * The path item value.
-     */
-    readonly value: unknown;
-}
-/**
- * Issue path item type.
- */
-type IssuePathItem = ArrayPathItem | MapPathItem | ObjectPathItem | SetPathItem | UnknownPathItem;
-/**
- * Base issue interface.
- */
-interface BaseIssue<TInput> extends Config<BaseIssue<TInput>> {
-    /**
-     * The issue kind.
-     */
-    readonly kind: 'schema' | 'validation' | 'transformation';
-    /**
-     * The issue type.
-     */
-    readonly type: string;
-    /**
-     * The raw input data.
-     */
-    readonly input: TInput;
-    /**
-     * The expected property.
-     */
-    readonly expected: string | null;
-    /**
-     * The received property.
-     */
-    readonly received: string;
-    /**
-     * The error message.
-     */
-    readonly message: string;
-    /**
-     * The input requirement.
-     */
-    readonly requirement?: unknown | undefined;
-    /**
-     * The issue path.
-     */
-    readonly path?: [IssuePathItem, ...IssuePathItem[]] | undefined;
-    /**
-     * The sub issues.
-     */
-    readonly issues?: [BaseIssue<TInput>, ...BaseIssue<TInput>[]] | undefined;
-}
-
-/**
- * Config interface.
- */
-interface Config<TIssue extends BaseIssue<unknown>> {
-    /**
-     * The selected language.
-     */
-    readonly lang?: string | undefined;
-    /**
-     * The error message.
-     */
-    readonly message?: ErrorMessage<TIssue> | undefined;
-    /**
-     * Whether it should be aborted early.
-     */
-    readonly abortEarly?: boolean | undefined;
-    /**
-     * Whether a pipe should be aborted early.
-     */
-    readonly abortPipeEarly?: boolean | undefined;
-}
-
-/**
- * Pipe action type.
- */
-type PipeAction<TInput, TOutput, TIssue extends BaseIssue<unknown>> = BaseValidation<TInput, TOutput, TIssue> | BaseTransformation<TInput, TOutput, TIssue> | BaseMetadata<TInput>;
-/**
- * Pipe action async type.
- */
-type PipeActionAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> = BaseValidationAsync<TInput, TOutput, TIssue> | BaseTransformationAsync<TInput, TOutput, TIssue>;
-/**
- * Pipe item type.
- */
-type PipeItem<TInput, TOutput, TIssue extends BaseIssue<unknown>> = BaseSchema<TInput, TOutput, TIssue> | PipeAction<TInput, TOutput, TIssue>;
-/**
- * Pipe item async type.
- */
-type PipeItemAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> = BaseSchemaAsync<TInput, TOutput, TIssue> | PipeActionAsync<TInput, TOutput, TIssue>;
-
-/**
- * Array issue interface.
- */
-interface ArrayIssue extends BaseIssue<unknown> {
-    /**
-     * The issue kind.
-     */
-    readonly kind: 'schema';
-    /**
-     * The issue type.
-     */
-    readonly type: 'array';
-    /**
-     * The expected property.
-     */
-    readonly expected: 'Array';
-}
-
-/**
- * Array schema interface.
- */
-interface ArraySchema<TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TMessage extends ErrorMessage<ArrayIssue> | undefined> extends BaseSchema<InferInput<TItem>[], InferOutput<TItem>[], ArrayIssue | InferIssue<TItem>> {
-    /**
-     * The schema type.
-     */
-    readonly type: 'array';
-    /**
-     * The schema reference.
-     */
-    readonly reference: typeof array;
-    /**
-     * The expected property.
-     */
-    readonly expects: 'Array';
-    /**
-     * The array item schema.
-     */
-    readonly item: TItem;
-    /**
-     * The error message.
-     */
-    readonly message: TMessage;
-}
-/**
- * Creates an array schema.
- *
- * @param item The item schema.
- *
- * @returns An array schema.
- */
-declare function array<const TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(item: TItem): ArraySchema<TItem, undefined>;
-/**
- * Creates an array schema.
- *
- * @param item The item schema.
- * @param message The error message.
- *
- * @returns An array schema.
- */
-declare function array<const TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TMessage extends ErrorMessage<ArrayIssue> | undefined>(item: TItem, message: TMessage): ArraySchema<TItem, TMessage>;
-
-/**
- * Exact optional schema interface.
- */
-interface ExactOptionalSchema<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TDefault extends Default<TWrapped, never>> extends BaseSchema<InferInput<TWrapped>, InferOutput<TWrapped>, InferIssue<TWrapped>> {
-    /**
-     * The schema type.
-     */
-    readonly type: 'exact_optional';
-    /**
-     * The schema reference.
-     */
-    readonly reference: typeof exactOptional;
-    /**
-     * The expected property.
-     */
-    readonly expects: TWrapped['expects'];
-    /**
-     * The wrapped schema.
-     */
-    readonly wrapped: TWrapped;
-    /**
-     * The default value.
-     */
-    readonly default: TDefault;
-}
-/**
- * Creates an exact optional schema.
- *
- * @param wrapped The wrapped schema.
- *
- * @returns An exact optional schema.
- */
-declare function exactOptional<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): ExactOptionalSchema<TWrapped, undefined>;
-/**
- * Creates an exact optional schema.
- *
- * @param wrapped The wrapped schema.
- * @param default_ The default value.
- *
- * @returns An exact optional schema.
- */
-declare function exactOptional<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TDefault extends Default<TWrapped, never>>(wrapped: TWrapped, default_: TDefault): ExactOptionalSchema<TWrapped, TDefault>;
-
-/**
- * Exact optional schema async interface.
- */
-interface ExactOptionalSchemaAsync<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped, never>> extends BaseSchemaAsync<InferInput<TWrapped>, InferOutput<TWrapped>, InferIssue<TWrapped>> {
-    /**
-     * The schema type.
-     */
-    readonly type: 'exact_optional';
-    /**
-     * The schema reference.
-     */
-    readonly reference: typeof exactOptional | typeof exactOptionalAsync;
-    /**
-     * The expected property.
-     */
-    readonly expects: TWrapped['expects'];
-    /**
-     * The wrapped schema.
-     */
-    readonly wrapped: TWrapped;
-    /**
-     * The default value.
-     */
-    readonly default: TDefault;
-}
-/**
- * Creates an exact optional schema.
- *
- * @param wrapped The wrapped schema.
- *
- * @returns An exact optional schema.
- */
-declare function exactOptionalAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): ExactOptionalSchemaAsync<TWrapped, undefined>;
-/**
- * Creates an exact optional schema.
- *
- * @param wrapped The wrapped schema.
- * @param default_ The default value.
- *
- * @returns An exact optional schema.
- */
-declare function exactOptionalAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, const TDefault extends DefaultAsync<TWrapped, never>>(wrapped: TWrapped, default_: TDefault): ExactOptionalSchemaAsync<TWrapped, TDefault>;
-
-/**
- * Infer nullish output type.
- */
-type InferNullishOutput<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped, null | undefined>> = undefined extends TDefault ? InferOutput<TWrapped> | null | undefined : InferOutput<TWrapped> | Extract<DefaultValue<TDefault>, null | undefined>;
-
-/**
- * Nullish schema interface.
- */
-interface NullishSchema<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TDefault extends Default<TWrapped, null | undefined>> extends BaseSchema<InferInput<TWrapped> | null | undefined, InferNullishOutput<TWrapped, TDefault>, InferIssue<TWrapped>> {
-    /**
-     * The schema type.
-     */
-    readonly type: 'nullish';
-    /**
-     * The schema reference.
-     */
-    readonly reference: typeof nullish;
-    /**
-     * The expected property.
-     */
-    readonly expects: `(${TWrapped['expects']} | null | undefined)`;
-    /**
-     * The wrapped schema.
-     */
-    readonly wrapped: TWrapped;
-    /**
-     * The default value.
-     */
-    readonly default: TDefault;
-}
-/**
- * Creates a nullish schema.
- *
- * @param wrapped The wrapped schema.
- *
- * @returns A nullish schema.
- */
-declare function nullish<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): NullishSchema<TWrapped, undefined>;
-/**
- * Creates a nullish schema.
- *
- * @param wrapped The wrapped schema.
- * @param default_ The default value.
- *
- * @returns A nullish schema.
- */
-declare function nullish<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TDefault extends Default<TWrapped, null | undefined>>(wrapped: TWrapped, default_: TDefault): NullishSchema<TWrapped, TDefault>;
-
-/**
- * Nullish schema async interface.
- */
-interface NullishSchemaAsync<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped, null | undefined>> extends BaseSchemaAsync<InferInput<TWrapped> | null | undefined, InferNullishOutput<TWrapped, TDefault>, InferIssue<TWrapped>> {
-    /**
-     * The schema type.
-     */
-    readonly type: 'nullish';
-    /**
-     * The schema reference.
-     */
-    readonly reference: typeof nullish | typeof nullishAsync;
-    /**
-     * The expected property.
-     */
-    readonly expects: `(${TWrapped['expects']} | null | undefined)`;
-    /**
-     * The wrapped schema.
-     */
-    readonly wrapped: TWrapped;
-    /**
-     * The default value.
-     */
-    readonly default: TDefault;
-}
-/**
- * Creates a nullish schema.
- *
- * @param wrapped The wrapped schema.
- *
- * @returns A nullish schema.
- */
-declare function nullishAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): NullishSchemaAsync<TWrapped, undefined>;
-/**
- * Creates a nullish schema.
- *
- * @param wrapped The wrapped schema.
- * @param default_ The default value.
- *
- * @returns A nullish schema.
- */
-declare function nullishAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, const TDefault extends DefaultAsync<TWrapped, null | undefined>>(wrapped: TWrapped, default_: TDefault): NullishSchemaAsync<TWrapped, TDefault>;
-
-/**
- * Object issue interface.
- */
-interface ObjectIssue extends BaseIssue<unknown> {
-    /**
-     * The issue kind.
-     */
-    readonly kind: 'schema';
-    /**
-     * The issue type.
-     */
-    readonly type: 'object';
-    /**
-     * The expected property.
-     */
-    readonly expected: 'Object' | `"${string}"`;
-}
-
-/**
- * Object schema interface.
- */
-interface ObjectSchema<TEntries extends ObjectEntries, TMessage extends ErrorMessage<ObjectIssue> | undefined> extends BaseSchema<InferObjectInput<TEntries>, InferObjectOutput<TEntries>, ObjectIssue | InferObjectIssue<TEntries>> {
-    /**
-     * The schema type.
-     */
-    readonly type: 'object';
-    /**
-     * The schema reference.
-     */
-    readonly reference: typeof object;
-    /**
-     * The expected property.
-     */
-    readonly expects: 'Object';
-    /**
-     * The entries schema.
-     */
-    readonly entries: TEntries;
-    /**
-     * The error message.
-     */
-    readonly message: TMessage;
-}
-/**
- * Creates an object schema.
- *
- * Hint: This schema removes unknown entries. The output will only include the
- * entries you specify. To include unknown entries, use `looseObject`. To
- * return an issue for unknown entries, use `strictObject`. To include and
- * validate unknown entries, use `objectWithRest`.
- *
- * @param entries The entries schema.
- *
- * @returns An object schema.
- */
-declare function object<const TEntries extends ObjectEntries>(entries: TEntries): ObjectSchema<TEntries, undefined>;
-/**
- * Creates an object schema.
- *
- * Hint: This schema removes unknown entries. The output will only include the
- * entries you specify. To include unknown entries, use `looseObject`. To
- * return an issue for unknown entries, use `strictObject`. To include and
- * validate unknown entries, use `objectWithRest`.
- *
- * @param entries The entries schema.
- * @param message The error message.
- *
- * @returns An object schema.
- */
-declare function object<const TEntries extends ObjectEntries, const TMessage extends ErrorMessage<ObjectIssue> | undefined>(entries: TEntries, message: TMessage): ObjectSchema<TEntries, TMessage>;
-
-/**
- * Infer optional output type.
- */
-type InferOptionalOutput<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped, undefined>> = undefined extends TDefault ? InferOutput<TWrapped> | undefined : InferOutput<TWrapped> | Extract<DefaultValue<TDefault>, undefined>;
-
-/**
- * Optional schema interface.
- */
-interface OptionalSchema<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TDefault extends Default<TWrapped, undefined>> extends BaseSchema<InferInput<TWrapped> | undefined, InferOptionalOutput<TWrapped, TDefault>, InferIssue<TWrapped>> {
-    /**
-     * The schema type.
-     */
-    readonly type: 'optional';
-    /**
-     * The schema reference.
-     */
-    readonly reference: typeof optional;
-    /**
-     * The expected property.
-     */
-    readonly expects: `(${TWrapped['expects']} | undefined)`;
-    /**
-     * The wrapped schema.
-     */
-    readonly wrapped: TWrapped;
-    /**
-     * The default value.
-     */
-    readonly default: TDefault;
-}
-/**
- * Creates an optional schema.
- *
- * @param wrapped The wrapped schema.
- *
- * @returns An optional schema.
- */
-declare function optional<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): OptionalSchema<TWrapped, undefined>;
-/**
- * Creates an optional schema.
- *
- * @param wrapped The wrapped schema.
- * @param default_ The default value.
- *
- * @returns An optional schema.
- */
-declare function optional<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TDefault extends Default<TWrapped, undefined>>(wrapped: TWrapped, default_: TDefault): OptionalSchema<TWrapped, TDefault>;
-
-/**
- * Optional schema async interface.
- */
-interface OptionalSchemaAsync<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped, undefined>> extends BaseSchemaAsync<InferInput<TWrapped> | undefined, InferOptionalOutput<TWrapped, TDefault>, InferIssue<TWrapped>> {
-    /**
-     * The schema type.
-     */
-    readonly type: 'optional';
-    /**
-     * The schema reference.
-     */
-    readonly reference: typeof optional | typeof optionalAsync;
-    /**
-     * The expected property.
-     */
-    readonly expects: `(${TWrapped['expects']} | undefined)`;
-    /**
-     * The wrapped schema.
-     */
-    readonly wrapped: TWrapped;
-    /**
-     * The default value.
-     */
-    readonly default: TDefault;
-}
-/**
- * Creates an optional schema.
- *
- * @param wrapped The wrapped schema.
- *
- * @returns An optional schema.
- */
-declare function optionalAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): OptionalSchemaAsync<TWrapped, undefined>;
-/**
- * Creates an optional schema.
- *
- * @param wrapped The wrapped schema.
- * @param default_ The default value.
- *
- * @returns An optional schema.
- */
-declare function optionalAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, const TDefault extends DefaultAsync<TWrapped, undefined>>(wrapped: TWrapped, default_: TDefault): OptionalSchemaAsync<TWrapped, TDefault>;
-
-/**
- * String issue interface.
- */
-interface StringIssue extends BaseIssue<unknown> {
-    /**
-     * The issue kind.
-     */
-    readonly kind: 'schema';
-    /**
-     * The issue type.
-     */
-    readonly type: 'string';
-    /**
-     * The expected property.
-     */
-    readonly expected: 'string';
-}
-/**
- * String schema interface.
- */
-interface StringSchema<TMessage extends ErrorMessage<StringIssue> | undefined> extends BaseSchema<string, string, StringIssue> {
-    /**
-     * The schema type.
-     */
-    readonly type: 'string';
-    /**
-     * The schema reference.
-     */
-    readonly reference: typeof string;
-    /**
-     * The expected property.
-     */
-    readonly expects: 'string';
-    /**
-     * The error message.
-     */
-    readonly message: TMessage;
-}
-/**
- * Creates a string schema.
- *
- * @returns A string schema.
- */
-declare function string(): StringSchema<undefined>;
-/**
- * Creates a string schema.
- *
- * @param message The error message.
- *
- * @returns A string schema.
- */
-declare function string<const TMessage extends ErrorMessage<StringIssue> | undefined>(message: TMessage): StringSchema<TMessage>;
-/**
- * Length input type.
- */
-type LengthInput = string | ArrayLike<unknown>;
-
-/**
- * Description action interface.
- */
-interface DescriptionAction<TInput, TDescription extends string> extends BaseMetadata<TInput> {
-    /**
-     * The action type.
-     */
-    readonly type: 'description';
-    /**
-     * The action reference.
-     */
-    readonly reference: typeof description;
-    /**
-     * The description text.
-     */
-    readonly description: TDescription;
-}
-/**
- * Creates a description metadata action.
- *
- * @param description_ The description text.
- *
- * @returns A description action.
- */
-declare function description<TInput, TDescription extends string>(description_: TDescription): DescriptionAction<TInput, TDescription>;
-
-/**
- * Non empty issue interface.
- */
-interface NonEmptyIssue<TInput extends LengthInput> extends BaseIssue<TInput> {
-    /**
-     * The issue kind.
-     */
-    readonly kind: 'validation';
-    /**
-     * The issue type.
-     */
-    readonly type: 'non_empty';
-    /**
-     * The expected input.
-     */
-    readonly expected: '!0';
-    /**
-     * The received input.
-     */
-    readonly received: '0';
-}
-/**
- * Non empty action interface.
- */
-interface NonEmptyAction<TInput extends LengthInput, TMessage extends ErrorMessage<NonEmptyIssue<TInput>> | undefined> extends BaseValidation<TInput, TInput, NonEmptyIssue<TInput>> {
-    /**
-     * The action type.
-     */
-    readonly type: 'non_empty';
-    /**
-     * The action reference.
-     */
-    readonly reference: typeof nonEmpty;
-    /**
-     * The expected property.
-     */
-    readonly expects: '!0';
-    /**
-     * The error message.
-     */
-    readonly message: TMessage;
-}
-/**
- * Creates a non-empty validation action.
- *
- * @returns A non-empty action.
- */
-declare function nonEmpty<TInput extends LengthInput>(): NonEmptyAction<TInput, undefined>;
-/**
- * Creates a non-empty validation action.
- *
- * @param message The error message.
- *
- * @returns A non-empty action.
- */
-declare function nonEmpty<TInput extends LengthInput, const TMessage extends ErrorMessage<NonEmptyIssue<TInput>> | undefined>(message: TMessage): NonEmptyAction<TInput, TMessage>;
-
-/**
- * Readonly output type.
- */
-type ReadonlyOutput<TInput> = TInput extends Map<infer TKey, infer TValue> ? ReadonlyMap<TKey, TValue> : TInput extends Set<infer TValue> ? ReadonlySet<TValue> : Readonly<TInput>;
-/**
- * Readonly action interface.
- */
-interface ReadonlyAction<TInput> extends BaseTransformation<TInput, ReadonlyOutput<TInput>, never> {
-    /**
-     * The action type.
-     */
-    readonly type: 'readonly';
-    /**
-     * The action reference.
-     */
-    readonly reference: typeof readonly;
-}
-/**
- * Creates a readonly transformation action.
- *
- * @returns A readonly action.
- */
-declare function readonly<TInput>(): ReadonlyAction<TInput>;
-
-declare const ProjectConfig: ObjectSchema<{
-    readonly name: SchemaWithPipe<[StringSchema<undefined>, NonEmptyAction<string, undefined>, DescriptionAction<string, "Project name, must be unique in the workspace">]>;
-    readonly contactPerson: OptionalSchema<SchemaWithPipe<[StringSchema<undefined>, NonEmptyAction<string, undefined>, DescriptionAction<string, "A person who has been involved in creating or maintaining this project">]>, undefined>;
-    readonly exclude: OptionalSchema<SchemaWithPipe<[ArraySchema<StringSchema<undefined>, undefined>, DescriptionAction<string[], "List of file patterns to exclude from the project, default is [\"node_modules\"]">]>, undefined>;
-}, undefined>;
-type ProjectConfig = InferOutput<typeof ProjectConfig>;
-
-declare const idattr: unique symbol;
-declare module 'langium' {
-    interface LangiumDocument {
-        likec4ProjectId?: c4.ProjectId;
-    }
-    interface AstNodeDescription {
-        likec4ProjectId?: c4.ProjectId;
-    }
-}
-declare module './generated/ast' {
-    interface Element {
-        [idattr]?: c4.Fqn | undefined;
-    }
-    interface ElementView {
-        [idattr]?: c4.ViewId | undefined;
-    }
-    interface DynamicView {
-        [idattr]?: c4.ViewId | undefined;
-    }
-    interface DeploymentView {
-        [idattr]?: c4.ViewId | undefined;
-    }
-    interface DeploymentNode {
-        [idattr]?: c4.Fqn | undefined;
-    }
-    interface DeployedInstance {
-        [idattr]?: c4.Fqn | undefined;
-    }
-}
-
-type ModelParsedListener = (docs: URI[]) => void;
-interface LikeC4ModelBuilder {
-    parseModel(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<c4.ParsedLikeC4ModelData | null>;
-    unsafeSyncBuildModel(projectId: c4.ProjectId): LikeC4Model.Computed;
-    buildLikeC4Model(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model.Computed>;
-    computeView(viewId: ViewId, projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<c4.ComputedView | null>;
-    onModelParsed(callback: ModelParsedListener): Disposable;
-}
-
-type GraphvizOut = {
-    dot: string;
-    diagram: DiagramView;
-};
-type GraphvizSvgOut = {
-    id: ViewId;
-    dot: string;
-    svg: string;
-};
-interface LikeC4Views {
-    readonly layouter: GraphvizLayouter;
-    computedViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<ComputedView[]>;
-    layoutAllViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<Readonly<GraphvizOut>>>;
-    layoutView(viewId: ViewId, projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<GraphvizOut | null>;
-    diagrams(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<DiagramView>>;
-    viewsAsGraphvizOut(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<GraphvizSvgOut>>;
-    overviewGraph(): Promise<OverviewGraph>;
-}
-
-interface LikeC4LanguageServices {
-    readonly views: LikeC4Views;
-    readonly builder: LikeC4ModelBuilder;
-    readonly workspaceUri: URI;
-    projects(): NonEmptyArray<{
-        id: ProjectId;
-        folder: URI;
-        config: ProjectConfig;
-        documents: NonEmptyArray<URI> | null;
-    }>;
-    diagrams(): Promise<DiagramView[]>;
-    computedModel(project?: ProjectId | undefined): Promise<LikeC4Model.Computed>;
-    layoutedModel(project?: ProjectId | undefined): Promise<LikeC4Model.Layouted>;
-    getErrors(): Array<{
-        message: string;
-        line: number;
-        range: Range;
-        sourceFsPath: string;
-    }>;
-    notifyUpdate(update: {
-        changed?: string;
-        removed?: string;
-    }): Promise<boolean>;
-}
-
-export { type LikeC4LanguageServices as L, Range as R, type LikeC4Views as a };