likec4 1.36.0 → 1.37.0

package/dist/shared/{likec4.CoVNuZKl.d.mts → likec4.cqC6tNHO.d.mts}

@@ -2,7 +2,7 @@ import { Tagged, ValueOf, ConditionalPick, Writable, Simplify, MergeExclusive }
 import * as c4 from '@likec4/core';
 import { Fqn, EdgeId, AnyAux, aux, ComputedView, Specification, DiagramView, MultiMap as MultiMap$1, ProjectId, NonEmptyArray, NonEmptyReadonlyArray, ViewId, RelationId, DeploymentFqn, ViewChange } from '@likec4/core';
 import { LikeC4Model } from '@likec4/core/model';
-import picomatch from '/home/runner/work/likec4/likec4/node_modules/.pnpm/@types+picomatch@4.0.2/node_modules/@types/picomatch/posix.d.ts';
+import picomatch from '/home/runner/work/likec4/likec4/node_modules/.pnpm/@types+picomatch@4.0.2/node_modules/@types/picomatch/index.d.ts';
 import { ProjectId as ProjectId$1, Fqn as Fqn$1 } from '@likec4/core/types';
 import { DefaultWeakMap, MultiMap as MultiMap$2 } from '@likec4/core/utils';
 
@@ -7045,6 +7045,21 @@ interface ValidationOptions {
     /** If true, no further diagnostics are reported if there are linking errors. Lexing and parsing errors are reported first. */
     stopAfterLinkingErrors?: boolean;
 }
+declare class DefaultDocumentValidator implements DocumentValidator {
+    protected readonly validationRegistry: ValidationRegistry;
+    protected readonly metadata: LanguageMetaData;
+    constructor(services: LangiumCoreServices);
+    validateDocument(document: LangiumDocument, options?: ValidationOptions, cancelToken?: CancellationToken): Promise<Diagnostic[]>;
+    protected processLexingErrors(parseResult: ParseResult, diagnostics: Diagnostic[], _options: ValidationOptions): void;
+    protected processParsingErrors(parseResult: ParseResult, diagnostics: Diagnostic[], _options: ValidationOptions): void;
+    protected processLinkingErrors(document: LangiumDocument, diagnostics: Diagnostic[], _options: ValidationOptions): void;
+    protected validateAst(rootNode: AstNode, options: ValidationOptions, cancelToken?: CancellationToken): Promise<Diagnostic[]>;
+    protected validateAstBefore(rootNode: AstNode, options: ValidationOptions, acceptor: ValidationAcceptor, cancelToken?: CancellationToken): Promise<void>;
+    protected validateAstNodes(rootNode: AstNode, options: ValidationOptions, acceptor: ValidationAcceptor, cancelToken?: CancellationToken): Promise<void>;
+    protected validateAstAfter(rootNode: AstNode, options: ValidationOptions, acceptor: ValidationAcceptor, cancelToken?: CancellationToken): Promise<void>;
+    protected toDiagnostic<N extends AstNode>(severity: ValidationSeverity, message: string, info: DiagnosticInfo<N, string>): Diagnostic;
+    protected getSource(): string | undefined;
+}
 /**
  * Language-specific service for validating `LangiumDocument`s.
  */
@@ -14201,1995 +14216,473 @@ declare class LikeC4DocumentationProvider implements DocumentationProvider {
     getDocumentation(node: AstNode): string | undefined;
 }
 
-/**
- * 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 readonly [
-    BaseSchema<unknown, unknown, BaseIssue<unknown>>,
-    ...PipeItem<any, unknown, BaseIssue<unknown>>[]
-]> = Omit<FirstTupleItem<TPipe>, 'pipe' | '~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 readonly [
-    (BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>),
-    ...(PipeItem<any, unknown, BaseIssue<unknown>> | PipeItemAsync<any, unknown, BaseIssue<unknown>>)[]
-]> = Omit<FirstTupleItem<TPipe>, 'async' | 'pipe' | '~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;
-}
+/******************************************************************************
+ * This file was generated by langium-cli 3.5.2.
+ * DO NOT EDIT MANUALLY!
+ ******************************************************************************/
 
-/**
- * Unknown dataset interface.
- */
-interface UnknownDataset {
-    /**
-     * Whether is's typed.
-     */
-    typed?: false;
-    /**
-     * The dataset value.
-     */
-    value: unknown;
-    /**
-     * The dataset issues.
-     */
-    issues?: undefined;
+type ArrowType = 'crow' | 'diamond' | 'dot' | 'none' | 'normal' | 'odiamond' | 'odot' | 'onormal' | 'open' | 'vee';
+type BorderStyleValue = 'none' | LineOptions;
+type ColorLiteral = HexColor | RGBAColor;
+declare const ColorLiteral = "ColorLiteral";
+type CustomColorId = 'element' | 'model' | ArrowType | ElementShape | LineOptions | string;
+type DeploymentElement = DeployedInstance | DeploymentNode;
+declare const DeploymentElement = "DeploymentElement";
+type DeploymentNodeOrElementKind = DeploymentNodeKind | ElementKind;
+declare const DeploymentNodeOrElementKind = "DeploymentNodeOrElementKind";
+type DeploymentViewRule = DeploymentViewRulePredicate | DeploymentViewRuleStyle | ViewRuleAutoLayout;
+declare const DeploymentViewRule = "DeploymentViewRule";
+type DynamicViewRule = DynamicViewGlobalPredicateRef | DynamicViewIncludePredicate | ViewRuleAutoLayout | ViewRuleStyleOrGlobalRef;
+declare const DynamicViewRule = "DynamicViewRule";
+type ElementProperty = ElementStringProperty | ElementStyleProperty | IconProperty | LinkProperty | MetadataProperty;
+declare const ElementProperty = "ElementProperty";
+type ElementShape = 'browser' | 'cylinder' | 'mobile' | 'person' | 'queue' | 'rectangle' | 'storage';
+type ExpressionV2 = FqnExprOrWith | RelationExprOrWith;
+declare const ExpressionV2 = "ExpressionV2";
+type ExtendElementProperty = LinkProperty | MetadataProperty;
+declare const ExtendElementProperty = "ExtendElementProperty";
+type FqnExpr = ElementKindExpression | ElementTagExpression | FqnRefExpr | WildcardExpression;
+declare const FqnExpr = "FqnExpr";
+type FqnExprOrWhere = FqnExpr | FqnExprWhere;
+declare const FqnExprOrWhere = "FqnExprOrWhere";
+type FqnExprOrWith = FqnExprOrWhere | FqnExprWith;
+declare const FqnExprOrWith = "FqnExprOrWith";
+type FqnReferenceable = Element | ExtendDeployment | ExtendElement | Referenceable;
+declare const FqnReferenceable = "FqnReferenceable";
+type IconId = string;
+type Id = 'deployment' | 'element' | 'group' | 'instance' | 'model' | 'node' | ArrowType | ElementShape | LineOptions | Participant | SizeValue | ThemeColor | string;
+type LikeC4View = DeploymentView | DynamicView | ElementView;
+declare const LikeC4View = "LikeC4View";
+type LineOptions = 'dashed' | 'dotted' | 'solid';
+type MetadataProperty = MetadataBody;
+declare const MetadataProperty = "MetadataProperty";
+type ModelReferenceable = Element | Imported;
+declare const ModelReferenceable = "ModelReferenceable";
+type Participant = 'source' | 'target';
+type Referenceable = DeployedInstance | DeploymentNode | Element | Imported;
+declare const Referenceable = "Referenceable";
+type RelationExpr = DirectedRelationExpr | InOutRelationExpr | IncomingRelationExpr | OutgoingRelationExpr;
+declare const RelationExpr = "RelationExpr";
+type RelationExprOrWhere = RelationExpr | RelationExprWhere;
+declare const RelationExprOrWhere = "RelationExprOrWhere";
+type RelationExprOrWith = RelationExprOrWhere | RelationExprWith;
+declare const RelationExprOrWith = "RelationExprOrWith";
+type RelationProperty = LinkProperty | MetadataProperty | RelationNavigateToProperty | RelationStringProperty | RelationStyleProperty;
+declare const RelationProperty = "RelationProperty";
+type RelationshipStyleProperty = ArrowProperty | ColorProperty | LineProperty;
+declare const RelationshipStyleProperty = "RelationshipStyleProperty";
+type SizeProperty = PaddingSizeProperty | ShapeSizeProperty | TextSizeProperty;
+declare const SizeProperty = "SizeProperty";
+type SizeValue = 'large' | 'lg' | 'md' | 'medium' | 'sm' | 'small' | 'xl' | 'xlarge' | 'xs' | 'xsmall';
+type StringProperty = ElementStringProperty | MetadataAttribute | NotationProperty | NotesProperty | RelationStringProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | ViewStringProperty;
+declare const StringProperty = "StringProperty";
+type StyleProperty = BorderProperty | ColorProperty | IconProperty | MultipleProperty | OpacityProperty | PaddingSizeProperty | ShapeProperty | ShapeSizeProperty | TextSizeProperty;
+declare const StyleProperty = "StyleProperty";
+type ThemeColor = 'amber' | 'blue' | 'gray' | 'green' | 'indigo' | 'muted' | 'primary' | 'red' | 'secondary' | 'sky' | 'slate';
+type Uri = string;
+type ViewLayoutDirection = 'BottomTop' | 'LeftRight' | 'RightLeft' | 'TopBottom';
+type ViewProperty = LinkProperty | ViewStringProperty;
+declare const ViewProperty = "ViewProperty";
+type ViewRule = ViewRuleAutoLayout | ViewRuleGlobalPredicateRef | ViewRuleGroup | ViewRulePredicate | ViewRuleStyleOrGlobalRef;
+declare const ViewRule = "ViewRule";
+type ViewRuleStyleOrGlobalRef = ViewRuleGlobalStyle | ViewRuleStyle;
+declare const ViewRuleStyleOrGlobalRef = "ViewRuleStyleOrGlobalRef";
+type WhereElement = WhereElementKind | WhereElementTag;
+declare const WhereElement = "WhereElement";
+type WhereElementExpression = WhereBinaryExpression | WhereElement | WhereElementNegation;
+declare const WhereElementExpression = "WhereElementExpression";
+type WhereExpression = WhereElementExpression | WhereRelationExpression;
+declare const WhereExpression = "WhereExpression";
+type WhereKindEqual = WhereElementKind | WhereRelationKind | WhereRelationParticipantKind;
+declare const WhereKindEqual = "WhereKindEqual";
+type WhereRelation = WhereRelationKind | WhereRelationParticipantKind | WhereRelationParticipantTag | WhereRelationTag;
+declare const WhereRelation = "WhereRelation";
+type WhereRelationExpression = WhereBinaryExpression | WhereRelation | WhereRelationNegation;
+declare const WhereRelationExpression = "WhereRelationExpression";
+type WhereTagEqual = WhereElementTag | WhereRelationParticipantTag | WhereRelationTag;
+declare const WhereTagEqual = "WhereTagEqual";
+interface ArrowProperty extends AstNode {
+    readonly $container: CustomRelationProperties | RelationStyleProperty | SpecificationRelationshipKind;
+    readonly $type: 'ArrowProperty';
+    key: 'head' | 'tail';
+    value: ArrowType;
 }
-/**
- * Success dataset interface.
- */
-interface SuccessDataset<TValue> {
-    /**
-     * Whether is's typed.
-     */
-    typed: true;
-    /**
-     * The dataset value.
-     */
-    value: TValue;
-    /**
-     * The dataset issues.
-     */
-    issues?: undefined;
+declare const ArrowProperty = "ArrowProperty";
+interface BorderProperty extends AstNode {
+    readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
+    readonly $type: 'BorderProperty';
+    key: 'border';
+    value: BorderStyleValue;
 }
-/**
- * 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[]];
+declare const BorderProperty = "BorderProperty";
+interface ColorProperty extends AstNode {
+    readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | RelationStyleProperty | SpecificationRelationshipKind | ViewRuleGroup | ViewRuleStyle;
+    readonly $type: 'ColorProperty';
+    customColor?: Reference<CustomColor>;
+    key: 'color';
+    themeColor?: ThemeColor;
 }
-/**
- * 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[]];
+declare const ColorProperty = "ColorProperty";
+interface CustomColor extends AstNode {
+    readonly $container: SpecificationColor;
+    readonly $type: 'CustomColor';
+    name: CustomColorId;
 }
-/**
- * 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;
+declare const CustomColor = "CustomColor";
+interface CustomElementProperties extends AstNode {
+    readonly $container: FqnExprWith;
+    readonly $type: 'CustomElementProperties';
+    props: Array<ElementStringProperty | NavigateToProperty | NotationProperty | StyleProperty>;
 }
-/**
- * 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;
+declare const CustomElementProperties = "CustomElementProperties";
+interface CustomRelationProperties extends AstNode {
+    readonly $container: DynamicViewStep | RelationExprWith;
+    readonly $type: 'CustomRelationProperties';
+    props: Array<NotationProperty | NotesProperty | RelationNavigateToProperty | RelationStringProperty | RelationshipStyleProperty>;
 }
-/**
- * The result interface if validation fails.
- */
-interface StandardFailureResult {
-    /**
-     * The issues of failed validation.
-     */
-    readonly issues: readonly StandardIssue[];
+declare const CustomRelationProperties = "CustomRelationProperties";
+interface DeployedInstance extends AstNode {
+    readonly $container: DeploymentNodeBody | ExtendDeploymentBody;
+    readonly $type: 'DeployedInstance';
+    body?: DeployedInstanceBody;
+    name?: Id;
+    target: ElementRef;
+    title?: string;
 }
-/**
- * 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;
+declare const DeployedInstance = "DeployedInstance";
+interface DeployedInstanceBody extends AstNode {
+    readonly $container: DeployedInstance;
+    readonly $type: 'DeployedInstanceBody';
+    elements: Array<DeploymentRelation>;
+    props: Array<ElementProperty>;
+    tags?: Tags;
 }
-/**
- * The path item interface of the issue.
- */
-interface StandardPathItem {
-    /**
-     * The key of the path item.
-     */
-    readonly key: PropertyKey;
+declare const DeployedInstanceBody = "DeployedInstanceBody";
+interface DeploymentNode extends AstNode {
+    readonly $container: DeploymentNodeBody | ExtendDeploymentBody | ModelDeployments;
+    readonly $type: 'DeploymentNode';
+    body?: DeploymentNodeBody;
+    kind: Reference<DeploymentNodeKind>;
+    name: Id;
+    title?: string;
 }
-/**
- * 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;
+declare const DeploymentNode = "DeploymentNode";
+interface DeploymentNodeBody extends AstNode {
+    readonly $container: DeploymentNode;
+    readonly $type: 'DeploymentNodeBody';
+    elements: Array<DeployedInstance | DeploymentNode | DeploymentRelation>;
+    props: Array<ElementProperty>;
+    tags?: Tags;
 }
-
-/**
- * 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;
+declare const DeploymentNodeBody = "DeploymentNodeBody";
+interface DeploymentNodeKind extends AstNode {
+    readonly $container: SpecificationDeploymentNodeKind;
+    readonly $type: 'DeploymentNodeKind';
+    name: Id;
 }
-/**
- * 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>>;
+declare const DeploymentNodeKind = "DeploymentNodeKind";
+interface DeploymentRelation extends AstNode {
+    readonly $container: DeployedInstanceBody | DeploymentNodeBody | ExtendDeploymentBody | ModelDeployments;
+    readonly $type: 'DeploymentRelation';
+    body?: DeploymentRelationBody;
+    description?: string;
+    dotKind?: RelationKindDotRef;
+    kind?: Reference<RelationshipKind>;
+    source?: FqnRef;
+    tags?: Tags;
+    target: FqnRef;
+    technology?: string;
+    title?: string;
 }
-
-/**
- * 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;
+declare const DeploymentRelation = "DeploymentRelation";
+interface DeploymentRelationBody extends AstNode {
+    readonly $container: DeploymentRelation;
+    readonly $type: 'DeploymentRelationBody';
+    props: Array<RelationProperty>;
+    tags?: Tags;
 }
-/**
- * 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>>;
+declare const DeploymentRelationBody = "DeploymentRelationBody";
+interface DeploymentView extends AstNode {
+    readonly $container: ModelViews;
+    readonly $type: 'DeploymentView';
+    body?: DeploymentViewBody;
+    name: Id;
 }
-
-/**
- * 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;
+declare const DeploymentView = "DeploymentView";
+interface DeploymentViewBody extends AstNode {
+    readonly $container: DeploymentView;
+    readonly $type: 'DeploymentViewBody';
+    props: Array<ViewProperty>;
+    rules: Array<DeploymentViewRule>;
+    tags?: Tags;
 }
-/**
- * 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>>;
+declare const DeploymentViewBody = "DeploymentViewBody";
+interface DeploymentViewRulePredicate extends AstNode {
+    readonly $container: DeploymentViewBody;
+    readonly $type: 'DeploymentViewRulePredicate';
+    expr: Expressions;
+    isInclude: boolean;
 }
-
-/**
- * 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> = {
-    [TKey in keyof TObject]?: unknown;
-} & Omit<TObject, TKeys> & Partial<Pick<TObject, TKeys>>;
-/**
- * Extracts first tuple item.
- */
-type FirstTupleItem<TTuple extends readonly [unknown, ...unknown[]]> = TTuple[0];
-/**
- * Extracts last tuple item.
- */
-type LastTupleItem<TTuple extends readonly [unknown, ...unknown[]]> = TTuple[TTuple extends readonly [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;
+declare const DeploymentViewRulePredicate = "DeploymentViewRulePredicate";
+interface DeploymentViewRuleStyle extends AstNode {
+    readonly $container: DeploymentViewBody;
+    readonly $type: 'DeploymentViewRuleStyle';
+    props: Array<NotationProperty | StyleProperty>;
+    targets: FqnExpressions;
 }
-/**
- * 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;
+declare const DeploymentViewRuleStyle = "DeploymentViewRuleStyle";
+interface DirectedRelationExpr extends AstNode {
+    readonly $container: Expressions | RelationExprWhere | RelationExprWith;
+    readonly $type: 'DirectedRelationExpr';
+    source: OutgoingRelationExpr;
+    target: FqnExpr;
 }
-/**
- * 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;
+declare const DirectedRelationExpr = "DirectedRelationExpr";
+interface DynamicView extends AstNode {
+    readonly $container: ModelViews;
+    readonly $type: 'DynamicView';
+    body?: DynamicViewBody;
+    name: Id;
 }
-/**
- * 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;
+declare const DynamicView = "DynamicView";
+interface DynamicViewBody extends AstNode {
+    readonly $container: DynamicView;
+    readonly $type: 'DynamicViewBody';
+    props: Array<ViewProperty>;
+    rules: Array<DynamicViewRule>;
+    steps: Array<DynamicViewParallelSteps | DynamicViewStep>;
+    tags?: Tags;
 }
-/**
- * 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;
+declare const DynamicViewBody = "DynamicViewBody";
+interface DynamicViewGlobalPredicateRef extends AstNode {
+    readonly $container: DynamicViewBody;
+    readonly $type: 'DynamicViewGlobalPredicateRef';
+    predicate: Reference<GlobalDynamicPredicateGroup>;
 }
-/**
- * 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;
+declare const DynamicViewGlobalPredicateRef = "DynamicViewGlobalPredicateRef";
+interface DynamicViewIncludePredicate extends AstNode {
+    readonly $container: DynamicViewBody | GlobalDynamicPredicateGroup;
+    readonly $type: 'DynamicViewIncludePredicate';
+    exprs: Expressions;
 }
-/**
- * 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;
+declare const DynamicViewIncludePredicate = "DynamicViewIncludePredicate";
+interface DynamicViewParallelSteps extends AstNode {
+    readonly $container: DynamicViewBody;
+    readonly $type: 'DynamicViewParallelSteps';
+    steps: Array<DynamicViewStep>;
 }
-/**
- * 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;
+declare const DynamicViewParallelSteps = "DynamicViewParallelSteps";
+interface DynamicViewRef extends AstNode {
+    readonly $container: RelationNavigateToProperty;
+    readonly $type: 'DynamicViewRef';
+    view: Reference<DynamicView>;
 }
-
-/**
- * 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';
+declare const DynamicViewRef = "DynamicViewRef";
+interface DynamicViewStep extends AstNode {
+    readonly $container: DynamicViewBody | DynamicViewParallelSteps;
+    readonly $type: 'DynamicViewStep';
+    custom?: CustomRelationProperties;
+    dotKind?: RelationKindDotRef;
+    isBackward: boolean;
+    kind?: Reference<RelationshipKind>;
+    source: ElementRef;
+    target: ElementRef;
+    title?: string;
 }
-
-/**
- * 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;
+declare const DynamicViewStep = "DynamicViewStep";
+interface Element extends AstNode {
+    readonly $container: ElementBody | ExtendElementBody | Model;
+    readonly $type: 'Element';
+    body?: ElementBody;
+    kind: Reference<ElementKind>;
+    name: Id;
+    props: Array<string>;
 }
-/**
- * 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;
+declare const Element = "Element";
+interface ElementBody extends AstNode {
+    readonly $container: Element;
+    readonly $type: 'ElementBody';
+    elements: Array<Element | Relation>;
+    props: Array<ElementProperty>;
+    tags?: Tags;
 }
-/**
- * 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;
+declare const ElementBody = "ElementBody";
+interface ElementKind extends AstNode {
+    readonly $container: SpecificationElementKind;
+    readonly $type: 'ElementKind';
+    name: Id;
 }
-/**
- * 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;
+declare const ElementKind = "ElementKind";
+interface ElementKindExpression extends AstNode {
+    readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
+    readonly $type: 'ElementKindExpression';
+    isEqual: boolean;
+    kind: Reference<ElementKind>;
 }
-/**
- * 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;
+declare const ElementKindExpression = "ElementKindExpression";
+interface ElementRef extends AstNode {
+    readonly $container: DeployedInstance | DynamicViewStep | ElementView;
+    readonly $type: 'ElementRef';
+    modelElement: FqnRef;
 }
-/**
- * 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}"`;
+declare const ElementRef = "ElementRef";
+interface ElementStringProperty extends AstNode {
+    readonly $container: CustomElementProperties | DeployedInstanceBody | DeploymentNodeBody | ElementBody;
+    readonly $type: 'ElementStringProperty';
+    key: 'description' | 'technology' | 'title';
+    value: MarkdownOrString;
 }
-
-/**
- * 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;
+declare const ElementStringProperty = "ElementStringProperty";
+interface ElementStyleProperty extends AstNode {
+    readonly $container: DeployedInstanceBody | DeploymentNodeBody | ElementBody | SpecificationDeploymentNodeKind | SpecificationElementKind;
+    readonly $type: 'ElementStyleProperty';
+    key: 'style';
+    props: Array<StyleProperty>;
 }
-/**
- * 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;
+declare const ElementStyleProperty = "ElementStyleProperty";
+interface ElementTagExpression extends AstNode {
+    readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
+    readonly $type: 'ElementTagExpression';
+    isEqual: boolean;
+    tag: TagRef;
 }
-/**
- * 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;
+declare const ElementTagExpression = "ElementTagExpression";
+interface ElementView extends AstNode {
+    readonly $container: ModelViews;
+    readonly $type: 'ElementView';
+    body?: ElementViewBody;
+    extends?: ElementViewRef;
+    name?: Id;
+    viewOf?: ElementRef;
 }
-/**
- * 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';
+declare const ElementView = "ElementView";
+interface ElementViewBody extends AstNode {
+    readonly $container: ElementView;
+    readonly $type: 'ElementViewBody';
+    props: Array<ViewProperty>;
+    rules: Array<ViewRule>;
+    tags?: Tags;
 }
-/**
- * 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;
+declare const ElementViewBody = "ElementViewBody";
+interface ElementViewRef extends AstNode {
+    readonly $container: ElementView;
+    readonly $type: 'ElementViewRef';
+    view: Reference<ElementView>;
 }
-/**
- * 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>;
-/**
- * Content input type.
- */
-type ContentInput = string | MaybeReadonly<unknown[]>;
-/**
- * Content requirement type.
- */
-type ContentRequirement<TInput extends ContentInput> = TInput extends readonly unknown[] ? TInput[number] : TInput;
-/**
- * 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;
+declare const ElementViewRef = "ElementViewRef";
+interface Expressions extends AstNode {
+    readonly $container: DeploymentViewRulePredicate | DynamicViewIncludePredicate | Expressions | ViewRulePredicate;
+    readonly $type: 'Expressions';
+    prev?: Expressions;
+    value: ExpressionV2;
 }
-/**
- * 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>;
-
-/**
- * Excludes issue interface.
- */
-interface ExcludesIssue<TInput extends ContentInput, TRequirement extends ContentRequirement<TInput>> extends BaseIssue<TInput> {
-    /**
-     * The issue kind.
-     */
-    readonly kind: 'validation';
-    /**
-     * The issue type.
-     */
-    readonly type: 'excludes';
-    /**
-     * The expected property.
-     */
-    readonly expected: string;
-    /**
-     * The content to be excluded.
-     */
-    readonly requirement: TRequirement;
+declare const Expressions = "Expressions";
+interface ExtendDeployment extends AstNode {
+    readonly $container: ModelDeployments;
+    readonly $type: 'ExtendDeployment';
+    body: ExtendDeploymentBody;
+    deploymentNode: StrictFqnRef;
 }
-/**
- * Excludes action interface.
- */
-interface ExcludesAction<TInput extends ContentInput, TRequirement extends ContentRequirement<TInput>, TMessage extends ErrorMessage<ExcludesIssue<TInput, TRequirement>> | undefined> extends BaseValidation<TInput, TInput, ExcludesIssue<TInput, TRequirement>> {
-    /**
-     * The action type.
-     */
-    readonly type: 'excludes';
-    /**
-     * The action reference.
-     */
-    readonly reference: typeof excludes;
-    /**
-     * The expected property.
-     */
-    readonly expects: string;
-    /**
-     * The content to be excluded.
-     */
-    readonly requirement: TRequirement;
-    /**
-     * The error message.
-     */
-    readonly message: TMessage;
+declare const ExtendDeployment = "ExtendDeployment";
+interface ExtendDeploymentBody extends AstNode {
+    readonly $container: ExtendDeployment;
+    readonly $type: 'ExtendDeploymentBody';
+    elements: Array<DeployedInstance | DeploymentNode | DeploymentRelation>;
+    props: Array<ExtendElementProperty>;
+    tags?: Tags;
 }
-/**
- * Creates an excludes validation action.
- *
- * @param requirement The content to be excluded.
- *
- * @returns An excludes action.
- */
-declare function excludes<TInput extends ContentInput, const TRequirement extends ContentRequirement<TInput>>(requirement: TRequirement): ExcludesAction<TInput, TRequirement, undefined>;
-/**
- * Creates an excludes validation action.
- *
- * @param requirement The content to be excluded.
- * @param message The error message.
- *
- * @returns An excludes action.
- */
-declare function excludes<TInput extends ContentInput, const TRequirement extends ContentRequirement<TInput>, const TMessage extends ErrorMessage<ExcludesIssue<TInput, TRequirement>> | undefined>(requirement: TRequirement, message: TMessage): ExcludesAction<TInput, TRequirement, TMessage>;
-
-/**
- * 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';
+declare const ExtendDeploymentBody = "ExtendDeploymentBody";
+interface ExtendElement extends AstNode {
+    readonly $container: Model;
+    readonly $type: 'ExtendElement';
+    body: ExtendElementBody;
+    element: StrictFqnElementRef;
 }
-/**
- * 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;
+declare const ExtendElement = "ExtendElement";
+interface ExtendElementBody extends AstNode {
+    readonly $container: ExtendElement;
+    readonly $type: 'ExtendElementBody';
+    elements: Array<Element | Relation>;
+    props: Array<ExtendElementProperty>;
+    tags?: Tags;
 }
-/**
- * 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;
+declare const ExtendElementBody = "ExtendElementBody";
+interface FqnExpressions extends AstNode {
+    readonly $container: DeploymentViewRuleStyle | FqnExpressions | GlobalStyle | ViewRuleStyle;
+    readonly $type: 'FqnExpressions';
+    prev?: FqnExpressions;
+    value: FqnExpr;
 }
-/**
- * Creates a readonly transformation action.
- *
- * @returns A readonly action.
- */
-declare function readonly<TInput>(): ReadonlyAction<TInput>;
-
-declare const ProjectConfig: ObjectSchema<{
-    readonly name: SchemaWithPipe<readonly [StringSchema<undefined>, NonEmptyAction<string, "Project name cannot be empty">, ExcludesAction<string, "default", "Project name cannot be \"default\"">, ExcludesAction<string, ".", "Project name cannot contain \".\", try to use A-z, 0-9, _ and -">, ExcludesAction<string, "@", "Project name cannot contain \"@\", try to use A-z, 0-9, _ and -">, ExcludesAction<string, "#", "Project name cannot contain \"#\", try to use A-z, 0-9, _ and -">, DescriptionAction<string, "Project name, must be unique in the workspace">]>;
-    readonly title: OptionalSchema<SchemaWithPipe<readonly [StringSchema<undefined>, NonEmptyAction<string, "Project title cannot be empty if specified">, DescriptionAction<string, "A human readable title for the project">]>, undefined>;
-    readonly contactPerson: OptionalSchema<SchemaWithPipe<readonly [StringSchema<undefined>, NonEmptyAction<string, "Contact person cannot be empty if specified">, DescriptionAction<string, "A person who has been involved in creating or maintaining this project">]>, undefined>;
-    readonly exclude: OptionalSchema<SchemaWithPipe<readonly [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>;
-
-/******************************************************************************
- * This file was generated by langium-cli 3.5.2.
- * DO NOT EDIT MANUALLY!
- ******************************************************************************/
-
-type ArrowType = 'crow' | 'diamond' | 'dot' | 'none' | 'normal' | 'odiamond' | 'odot' | 'onormal' | 'open' | 'vee';
-type BorderStyleValue = 'none' | LineOptions;
-type ColorLiteral = HexColor | RGBAColor;
-declare const ColorLiteral = "ColorLiteral";
-type CustomColorId = 'element' | 'model' | ArrowType | ElementShape | LineOptions | string;
-type DeploymentElement = DeployedInstance | DeploymentNode;
-declare const DeploymentElement = "DeploymentElement";
-type DeploymentNodeOrElementKind = DeploymentNodeKind | ElementKind;
-declare const DeploymentNodeOrElementKind = "DeploymentNodeOrElementKind";
-type DeploymentViewRule = DeploymentViewRulePredicate | DeploymentViewRuleStyle | ViewRuleAutoLayout;
-declare const DeploymentViewRule = "DeploymentViewRule";
-type DynamicViewRule = DynamicViewGlobalPredicateRef | DynamicViewIncludePredicate | ViewRuleAutoLayout | ViewRuleStyleOrGlobalRef;
-declare const DynamicViewRule = "DynamicViewRule";
-type ElementProperty = ElementStringProperty | ElementStyleProperty | IconProperty | LinkProperty | MetadataProperty;
-declare const ElementProperty = "ElementProperty";
-type ElementShape = 'browser' | 'cylinder' | 'mobile' | 'person' | 'queue' | 'rectangle' | 'storage';
-type ExpressionV2 = FqnExprOrWith | RelationExprOrWith;
-declare const ExpressionV2 = "ExpressionV2";
-type ExtendElementProperty = LinkProperty | MetadataProperty;
-declare const ExtendElementProperty = "ExtendElementProperty";
-type FqnExpr = ElementKindExpression | ElementTagExpression | FqnRefExpr | WildcardExpression;
-declare const FqnExpr = "FqnExpr";
-type FqnExprOrWhere = FqnExpr | FqnExprWhere;
-declare const FqnExprOrWhere = "FqnExprOrWhere";
-type FqnExprOrWith = FqnExprOrWhere | FqnExprWith;
-declare const FqnExprOrWith = "FqnExprOrWith";
-type FqnReferenceable = Element | ExtendDeployment | ExtendElement | Referenceable;
-declare const FqnReferenceable = "FqnReferenceable";
-type IconId = string;
-type Id = 'deployment' | 'element' | 'group' | 'instance' | 'model' | 'node' | ArrowType | ElementShape | LineOptions | Participant | SizeValue | ThemeColor | string;
-type LikeC4View = DeploymentView | DynamicView | ElementView;
-declare const LikeC4View = "LikeC4View";
-type LineOptions = 'dashed' | 'dotted' | 'solid';
-type MetadataProperty = MetadataBody;
-declare const MetadataProperty = "MetadataProperty";
-type ModelReferenceable = Element | Imported;
-declare const ModelReferenceable = "ModelReferenceable";
-type Participant = 'source' | 'target';
-type Referenceable = DeployedInstance | DeploymentNode | Element | Imported;
-declare const Referenceable = "Referenceable";
-type RelationExpr = DirectedRelationExpr | InOutRelationExpr | IncomingRelationExpr | OutgoingRelationExpr;
-declare const RelationExpr = "RelationExpr";
-type RelationExprOrWhere = RelationExpr | RelationExprWhere;
-declare const RelationExprOrWhere = "RelationExprOrWhere";
-type RelationExprOrWith = RelationExprOrWhere | RelationExprWith;
-declare const RelationExprOrWith = "RelationExprOrWith";
-type RelationProperty = LinkProperty | MetadataProperty | RelationNavigateToProperty | RelationStringProperty | RelationStyleProperty;
-declare const RelationProperty = "RelationProperty";
-type RelationshipStyleProperty = ArrowProperty | ColorProperty | LineProperty;
-declare const RelationshipStyleProperty = "RelationshipStyleProperty";
-type SizeProperty = PaddingSizeProperty | ShapeSizeProperty | TextSizeProperty;
-declare const SizeProperty = "SizeProperty";
-type SizeValue = 'large' | 'lg' | 'md' | 'medium' | 'sm' | 'small' | 'xl' | 'xlarge' | 'xs' | 'xsmall';
-type StringProperty = ElementStringProperty | MetadataAttribute | NotationProperty | NotesProperty | RelationStringProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | ViewStringProperty;
-declare const StringProperty = "StringProperty";
-type StyleProperty = BorderProperty | ColorProperty | IconProperty | MultipleProperty | OpacityProperty | PaddingSizeProperty | ShapeProperty | ShapeSizeProperty | TextSizeProperty;
-declare const StyleProperty = "StyleProperty";
-type ThemeColor = 'amber' | 'blue' | 'gray' | 'green' | 'indigo' | 'muted' | 'primary' | 'red' | 'secondary' | 'sky' | 'slate';
-type Uri = string;
-type ViewLayoutDirection = 'BottomTop' | 'LeftRight' | 'RightLeft' | 'TopBottom';
-type ViewProperty = LinkProperty | ViewStringProperty;
-declare const ViewProperty = "ViewProperty";
-type ViewRule = ViewRuleAutoLayout | ViewRuleGlobalPredicateRef | ViewRuleGroup | ViewRulePredicate | ViewRuleStyleOrGlobalRef;
-declare const ViewRule = "ViewRule";
-type ViewRuleStyleOrGlobalRef = ViewRuleGlobalStyle | ViewRuleStyle;
-declare const ViewRuleStyleOrGlobalRef = "ViewRuleStyleOrGlobalRef";
-type WhereElement = WhereElementKind | WhereElementTag;
-declare const WhereElement = "WhereElement";
-type WhereElementExpression = WhereBinaryExpression | WhereElement | WhereElementNegation;
-declare const WhereElementExpression = "WhereElementExpression";
-type WhereExpression = WhereElementExpression | WhereRelationExpression;
-declare const WhereExpression = "WhereExpression";
-type WhereKindEqual = WhereElementKind | WhereRelationKind | WhereRelationParticipantKind;
-declare const WhereKindEqual = "WhereKindEqual";
-type WhereRelation = WhereRelationKind | WhereRelationParticipantKind | WhereRelationParticipantTag | WhereRelationTag;
-declare const WhereRelation = "WhereRelation";
-type WhereRelationExpression = WhereBinaryExpression | WhereRelation | WhereRelationNegation;
-declare const WhereRelationExpression = "WhereRelationExpression";
-type WhereTagEqual = WhereElementTag | WhereRelationParticipantTag | WhereRelationTag;
-declare const WhereTagEqual = "WhereTagEqual";
-interface ArrowProperty extends AstNode {
-    readonly $container: CustomRelationProperties | RelationStyleProperty | SpecificationRelationshipKind;
-    readonly $type: 'ArrowProperty';
-    key: 'head' | 'tail';
-    value: ArrowType;
+declare const FqnExpressions = "FqnExpressions";
+interface FqnExprWhere extends AstNode {
+    readonly $container: Expressions | FqnExprWith;
+    readonly $type: 'FqnExprWhere';
+    subject: FqnExpr;
+    where?: WhereElementExpression;
 }
-declare const ArrowProperty = "ArrowProperty";
-interface BorderProperty extends AstNode {
-    readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
-    readonly $type: 'BorderProperty';
-    key: 'border';
-    value: BorderStyleValue;
+declare const FqnExprWhere = "FqnExprWhere";
+interface FqnExprWith extends AstNode {
+    readonly $container: Expressions;
+    readonly $type: 'FqnExprWith';
+    custom?: CustomElementProperties;
+    subject: FqnExprOrWhere;
 }
-declare const BorderProperty = "BorderProperty";
-interface ColorProperty extends AstNode {
-    readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | RelationStyleProperty | SpecificationRelationshipKind | ViewRuleGroup | ViewRuleStyle;
-    readonly $type: 'ColorProperty';
-    customColor?: Reference<CustomColor>;
-    key: 'color';
-    themeColor?: ThemeColor;
+declare const FqnExprWith = "FqnExprWith";
+interface FqnRef extends AstNode {
+    readonly $container: DeploymentRelation | ElementRef | FqnRef | FqnRefExpr | Relation;
+    readonly $type: 'FqnRef';
+    parent?: FqnRef;
+    value: Reference<Referenceable>;
 }
-declare const ColorProperty = "ColorProperty";
-interface CustomColor extends AstNode {
-    readonly $container: SpecificationColor;
-    readonly $type: 'CustomColor';
-    name: CustomColorId;
+declare const FqnRef = "FqnRef";
+interface FqnRefExpr extends AstNode {
+    readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
+    readonly $type: 'FqnRefExpr';
+    ref: FqnRef;
+    selector?: string;
 }
-declare const CustomColor = "CustomColor";
-interface CustomElementProperties extends AstNode {
-    readonly $container: FqnExprWith;
-    readonly $type: 'CustomElementProperties';
-    props: Array<ElementStringProperty | NavigateToProperty | NotationProperty | StyleProperty>;
+declare const FqnRefExpr = "FqnRefExpr";
+interface GlobalDynamicPredicateGroup extends AstNode {
+    readonly $container: Globals;
+    readonly $type: 'GlobalDynamicPredicateGroup';
+    name: string;
+    predicates: Array<DynamicViewIncludePredicate>;
 }
-declare const CustomElementProperties = "CustomElementProperties";
-interface CustomRelationProperties extends AstNode {
-    readonly $container: DynamicViewStep | RelationExprWith;
-    readonly $type: 'CustomRelationProperties';
-    props: Array<NotationProperty | NotesProperty | RelationNavigateToProperty | RelationStringProperty | RelationshipStyleProperty>;
+declare const GlobalDynamicPredicateGroup = "GlobalDynamicPredicateGroup";
+interface GlobalPredicateGroup extends AstNode {
+    readonly $container: Globals;
+    readonly $type: 'GlobalPredicateGroup';
+    name: string;
+    predicates: Array<ViewRulePredicate>;
 }
-declare const CustomRelationProperties = "CustomRelationProperties";
-interface DeployedInstance extends AstNode {
-    readonly $container: DeploymentNodeBody | ExtendDeploymentBody;
-    readonly $type: 'DeployedInstance';
-    body?: DeployedInstanceBody;
-    name?: Id;
-    target: ElementRef;
-    title?: string;
+declare const GlobalPredicateGroup = "GlobalPredicateGroup";
+interface Globals extends AstNode {
+    readonly $container: LikeC4Grammar;
+    readonly $type: 'Globals';
+    name: 'global';
+    predicates: Array<GlobalDynamicPredicateGroup | GlobalPredicateGroup>;
+    styles: Array<GlobalStyle | GlobalStyleGroup>;
 }
-declare const DeployedInstance = "DeployedInstance";
-interface DeployedInstanceBody extends AstNode {
-    readonly $container: DeployedInstance;
-    readonly $type: 'DeployedInstanceBody';
-    elements: Array<DeploymentRelation>;
-    props: Array<ElementProperty>;
-    tags?: Tags;
+declare const Globals = "Globals";
+interface GlobalStyle extends AstNode {
+    readonly $container: Globals;
+    readonly $type: 'GlobalStyle';
+    id: GlobalStyleId;
+    props: Array<NotationProperty | StyleProperty>;
+    targets: FqnExpressions;
 }
-declare const DeployedInstanceBody = "DeployedInstanceBody";
-interface DeploymentNode extends AstNode {
-    readonly $container: DeploymentNodeBody | ExtendDeploymentBody | ModelDeployments;
-    readonly $type: 'DeploymentNode';
-    body?: DeploymentNodeBody;
-    kind: Reference<DeploymentNodeKind>;
-    name: Id;
-    title?: string;
+declare const GlobalStyle = "GlobalStyle";
+interface GlobalStyleGroup extends AstNode {
+    readonly $container: Globals;
+    readonly $type: 'GlobalStyleGroup';
+    id: GlobalStyleId;
+    styles: Array<ViewRuleStyle>;
 }
-declare const DeploymentNode = "DeploymentNode";
-interface DeploymentNodeBody extends AstNode {
-    readonly $container: DeploymentNode;
-    readonly $type: 'DeploymentNodeBody';
-    elements: Array<DeployedInstance | DeploymentNode | DeploymentRelation>;
-    props: Array<ElementProperty>;
-    tags?: Tags;
-}
-declare const DeploymentNodeBody = "DeploymentNodeBody";
-interface DeploymentNodeKind extends AstNode {
-    readonly $container: SpecificationDeploymentNodeKind;
-    readonly $type: 'DeploymentNodeKind';
-    name: Id;
-}
-declare const DeploymentNodeKind = "DeploymentNodeKind";
-interface DeploymentRelation extends AstNode {
-    readonly $container: DeployedInstanceBody | DeploymentNodeBody | ExtendDeploymentBody | ModelDeployments;
-    readonly $type: 'DeploymentRelation';
-    body?: DeploymentRelationBody;
-    description?: string;
-    dotKind?: RelationKindDotRef;
-    kind?: Reference<RelationshipKind>;
-    source?: FqnRef;
-    tags?: Tags;
-    target: FqnRef;
-    technology?: string;
-    title?: string;
-}
-declare const DeploymentRelation = "DeploymentRelation";
-interface DeploymentRelationBody extends AstNode {
-    readonly $container: DeploymentRelation;
-    readonly $type: 'DeploymentRelationBody';
-    props: Array<RelationProperty>;
-    tags?: Tags;
-}
-declare const DeploymentRelationBody = "DeploymentRelationBody";
-interface DeploymentView extends AstNode {
-    readonly $container: ModelViews;
-    readonly $type: 'DeploymentView';
-    body?: DeploymentViewBody;
-    name: Id;
-}
-declare const DeploymentView = "DeploymentView";
-interface DeploymentViewBody extends AstNode {
-    readonly $container: DeploymentView;
-    readonly $type: 'DeploymentViewBody';
-    props: Array<ViewProperty>;
-    rules: Array<DeploymentViewRule>;
-    tags?: Tags;
-}
-declare const DeploymentViewBody = "DeploymentViewBody";
-interface DeploymentViewRulePredicate extends AstNode {
-    readonly $container: DeploymentViewBody;
-    readonly $type: 'DeploymentViewRulePredicate';
-    expr: Expressions;
-    isInclude: boolean;
-}
-declare const DeploymentViewRulePredicate = "DeploymentViewRulePredicate";
-interface DeploymentViewRuleStyle extends AstNode {
-    readonly $container: DeploymentViewBody;
-    readonly $type: 'DeploymentViewRuleStyle';
-    props: Array<NotationProperty | StyleProperty>;
-    targets: FqnExpressions;
-}
-declare const DeploymentViewRuleStyle = "DeploymentViewRuleStyle";
-interface DirectedRelationExpr extends AstNode {
-    readonly $container: Expressions | RelationExprWhere | RelationExprWith;
-    readonly $type: 'DirectedRelationExpr';
-    source: OutgoingRelationExpr;
-    target: FqnExpr;
-}
-declare const DirectedRelationExpr = "DirectedRelationExpr";
-interface DynamicView extends AstNode {
-    readonly $container: ModelViews;
-    readonly $type: 'DynamicView';
-    body?: DynamicViewBody;
-    name: Id;
-}
-declare const DynamicView = "DynamicView";
-interface DynamicViewBody extends AstNode {
-    readonly $container: DynamicView;
-    readonly $type: 'DynamicViewBody';
-    props: Array<ViewProperty>;
-    rules: Array<DynamicViewRule>;
-    steps: Array<DynamicViewParallelSteps | DynamicViewStep>;
-    tags?: Tags;
-}
-declare const DynamicViewBody = "DynamicViewBody";
-interface DynamicViewGlobalPredicateRef extends AstNode {
-    readonly $container: DynamicViewBody;
-    readonly $type: 'DynamicViewGlobalPredicateRef';
-    predicate: Reference<GlobalDynamicPredicateGroup>;
-}
-declare const DynamicViewGlobalPredicateRef = "DynamicViewGlobalPredicateRef";
-interface DynamicViewIncludePredicate extends AstNode {
-    readonly $container: DynamicViewBody | GlobalDynamicPredicateGroup;
-    readonly $type: 'DynamicViewIncludePredicate';
-    exprs: Expressions;
-}
-declare const DynamicViewIncludePredicate = "DynamicViewIncludePredicate";
-interface DynamicViewParallelSteps extends AstNode {
-    readonly $container: DynamicViewBody;
-    readonly $type: 'DynamicViewParallelSteps';
-    steps: Array<DynamicViewStep>;
-}
-declare const DynamicViewParallelSteps = "DynamicViewParallelSteps";
-interface DynamicViewRef extends AstNode {
-    readonly $container: RelationNavigateToProperty;
-    readonly $type: 'DynamicViewRef';
-    view: Reference<DynamicView>;
-}
-declare const DynamicViewRef = "DynamicViewRef";
-interface DynamicViewStep extends AstNode {
-    readonly $container: DynamicViewBody | DynamicViewParallelSteps;
-    readonly $type: 'DynamicViewStep';
-    custom?: CustomRelationProperties;
-    dotKind?: RelationKindDotRef;
-    isBackward: boolean;
-    kind?: Reference<RelationshipKind>;
-    source: ElementRef;
-    target: ElementRef;
-    title?: string;
-}
-declare const DynamicViewStep = "DynamicViewStep";
-interface Element extends AstNode {
-    readonly $container: ElementBody | ExtendElementBody | Model;
-    readonly $type: 'Element';
-    body?: ElementBody;
-    kind: Reference<ElementKind>;
-    name: Id;
-    props: Array<string>;
-}
-declare const Element = "Element";
-interface ElementBody extends AstNode {
-    readonly $container: Element;
-    readonly $type: 'ElementBody';
-    elements: Array<Element | Relation>;
-    props: Array<ElementProperty>;
-    tags?: Tags;
-}
-declare const ElementBody = "ElementBody";
-interface ElementKind extends AstNode {
-    readonly $container: SpecificationElementKind;
-    readonly $type: 'ElementKind';
-    name: Id;
-}
-declare const ElementKind = "ElementKind";
-interface ElementKindExpression extends AstNode {
-    readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
-    readonly $type: 'ElementKindExpression';
-    isEqual: boolean;
-    kind: Reference<ElementKind>;
-}
-declare const ElementKindExpression = "ElementKindExpression";
-interface ElementRef extends AstNode {
-    readonly $container: DeployedInstance | DynamicViewStep | ElementView;
-    readonly $type: 'ElementRef';
-    modelElement: FqnRef;
-}
-declare const ElementRef = "ElementRef";
-interface ElementStringProperty extends AstNode {
-    readonly $container: CustomElementProperties | DeployedInstanceBody | DeploymentNodeBody | ElementBody;
-    readonly $type: 'ElementStringProperty';
-    key: 'description' | 'technology' | 'title';
-    value: MarkdownOrString;
-}
-declare const ElementStringProperty = "ElementStringProperty";
-interface ElementStyleProperty extends AstNode {
-    readonly $container: DeployedInstanceBody | DeploymentNodeBody | ElementBody | SpecificationDeploymentNodeKind | SpecificationElementKind;
-    readonly $type: 'ElementStyleProperty';
-    key: 'style';
-    props: Array<StyleProperty>;
-}
-declare const ElementStyleProperty = "ElementStyleProperty";
-interface ElementTagExpression extends AstNode {
-    readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
-    readonly $type: 'ElementTagExpression';
-    isEqual: boolean;
-    tag: TagRef;
-}
-declare const ElementTagExpression = "ElementTagExpression";
-interface ElementView extends AstNode {
-    readonly $container: ModelViews;
-    readonly $type: 'ElementView';
-    body?: ElementViewBody;
-    extends?: ElementViewRef;
-    name?: Id;
-    viewOf?: ElementRef;
-}
-declare const ElementView = "ElementView";
-interface ElementViewBody extends AstNode {
-    readonly $container: ElementView;
-    readonly $type: 'ElementViewBody';
-    props: Array<ViewProperty>;
-    rules: Array<ViewRule>;
-    tags?: Tags;
-}
-declare const ElementViewBody = "ElementViewBody";
-interface ElementViewRef extends AstNode {
-    readonly $container: ElementView;
-    readonly $type: 'ElementViewRef';
-    view: Reference<ElementView>;
-}
-declare const ElementViewRef = "ElementViewRef";
-interface Expressions extends AstNode {
-    readonly $container: DeploymentViewRulePredicate | DynamicViewIncludePredicate | Expressions | ViewRulePredicate;
-    readonly $type: 'Expressions';
-    prev?: Expressions;
-    value: ExpressionV2;
-}
-declare const Expressions = "Expressions";
-interface ExtendDeployment extends AstNode {
-    readonly $container: ModelDeployments;
-    readonly $type: 'ExtendDeployment';
-    body: ExtendDeploymentBody;
-    deploymentNode: StrictFqnRef;
-}
-declare const ExtendDeployment = "ExtendDeployment";
-interface ExtendDeploymentBody extends AstNode {
-    readonly $container: ExtendDeployment;
-    readonly $type: 'ExtendDeploymentBody';
-    elements: Array<DeployedInstance | DeploymentNode | DeploymentRelation>;
-    props: Array<ExtendElementProperty>;
-    tags?: Tags;
-}
-declare const ExtendDeploymentBody = "ExtendDeploymentBody";
-interface ExtendElement extends AstNode {
-    readonly $container: Model;
-    readonly $type: 'ExtendElement';
-    body: ExtendElementBody;
-    element: StrictFqnElementRef;
-}
-declare const ExtendElement = "ExtendElement";
-interface ExtendElementBody extends AstNode {
-    readonly $container: ExtendElement;
-    readonly $type: 'ExtendElementBody';
-    elements: Array<Element | Relation>;
-    props: Array<ExtendElementProperty>;
-    tags?: Tags;
-}
-declare const ExtendElementBody = "ExtendElementBody";
-interface FqnExpressions extends AstNode {
-    readonly $container: DeploymentViewRuleStyle | FqnExpressions | GlobalStyle | ViewRuleStyle;
-    readonly $type: 'FqnExpressions';
-    prev?: FqnExpressions;
-    value: FqnExpr;
-}
-declare const FqnExpressions = "FqnExpressions";
-interface FqnExprWhere extends AstNode {
-    readonly $container: Expressions | FqnExprWith;
-    readonly $type: 'FqnExprWhere';
-    subject: FqnExpr;
-    where?: WhereElementExpression;
-}
-declare const FqnExprWhere = "FqnExprWhere";
-interface FqnExprWith extends AstNode {
-    readonly $container: Expressions;
-    readonly $type: 'FqnExprWith';
-    custom?: CustomElementProperties;
-    subject: FqnExprOrWhere;
-}
-declare const FqnExprWith = "FqnExprWith";
-interface FqnRef extends AstNode {
-    readonly $container: DeploymentRelation | ElementRef | FqnRef | FqnRefExpr | Relation;
-    readonly $type: 'FqnRef';
-    parent?: FqnRef;
-    value: Reference<Referenceable>;
-}
-declare const FqnRef = "FqnRef";
-interface FqnRefExpr extends AstNode {
-    readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
-    readonly $type: 'FqnRefExpr';
-    ref: FqnRef;
-    selector?: string;
-}
-declare const FqnRefExpr = "FqnRefExpr";
-interface GlobalDynamicPredicateGroup extends AstNode {
-    readonly $container: Globals;
-    readonly $type: 'GlobalDynamicPredicateGroup';
-    name: string;
-    predicates: Array<DynamicViewIncludePredicate>;
-}
-declare const GlobalDynamicPredicateGroup = "GlobalDynamicPredicateGroup";
-interface GlobalPredicateGroup extends AstNode {
-    readonly $container: Globals;
-    readonly $type: 'GlobalPredicateGroup';
-    name: string;
-    predicates: Array<ViewRulePredicate>;
-}
-declare const GlobalPredicateGroup = "GlobalPredicateGroup";
-interface Globals extends AstNode {
-    readonly $container: LikeC4Grammar;
-    readonly $type: 'Globals';
-    name: 'global';
-    predicates: Array<GlobalDynamicPredicateGroup | GlobalPredicateGroup>;
-    styles: Array<GlobalStyle | GlobalStyleGroup>;
-}
-declare const Globals = "Globals";
-interface GlobalStyle extends AstNode {
-    readonly $container: Globals;
-    readonly $type: 'GlobalStyle';
-    id: GlobalStyleId;
-    props: Array<NotationProperty | StyleProperty>;
-    targets: FqnExpressions;
-}
-declare const GlobalStyle = "GlobalStyle";
-interface GlobalStyleGroup extends AstNode {
-    readonly $container: Globals;
-    readonly $type: 'GlobalStyleGroup';
-    id: GlobalStyleId;
-    styles: Array<ViewRuleStyle>;
-}
-declare const GlobalStyleGroup = "GlobalStyleGroup";
-interface GlobalStyleId extends AstNode {
-    readonly $container: GlobalStyle | GlobalStyleGroup;
-    readonly $type: 'GlobalStyleId';
-    name: string;
+declare const GlobalStyleGroup = "GlobalStyleGroup";
+interface GlobalStyleId extends AstNode {
+    readonly $container: GlobalStyle | GlobalStyleGroup;
+    readonly $type: 'GlobalStyleId';
+    name: string;
 }
 declare const GlobalStyleId = "GlobalStyleId";
 interface HexColor extends AstNode {
@@ -16845,6 +15338,15 @@ type LikeC4AstType = {
     WildcardExpression: WildcardExpression;
 };
 
+declare class LikeC4DocumentValidator extends DefaultDocumentValidator {
+    protected services: LikeC4Services;
+    constructor(services: LikeC4Services);
+    /**
+     * If the document is excluded, then we skip validation and return an empty array of diagnostics.
+     */
+    validateDocument(document: LangiumDocument, options?: ValidationOptions, cancelToken?: CancellationToken): Promise<Diagnostic[]>;
+}
+
 type Guard<N extends AstNode> = (n: AstNode) => n is N;
 type Guarded<G> = G extends Guard<infer N> ? N : never;
 declare const isValidatableAstNode: (n: AstNode) => n is HexColor | RGBAColor | DeployedInstance | DeploymentNode | DeploymentViewRulePredicate | DeploymentViewRuleStyle | ViewRuleAutoLayout | DynamicViewGlobalPredicateRef | DynamicViewIncludePredicate | ViewRuleGlobalStyle | ViewRuleStyle | ElementStringProperty | ElementStyleProperty | IconProperty | LinkProperty | MetadataBody | ElementKindExpression | ElementTagExpression | FqnRefExpr | WildcardExpression | FqnExprWhere | FqnExprWith | DirectedRelationExpr | InOutRelationExpr | IncomingRelationExpr | OutgoingRelationExpr | RelationExprWhere | RelationExprWith | Element | ExtendDeployment | ExtendElement | Imported | DeploymentView | DynamicView | ElementView | RelationStringProperty | ArrowProperty | ColorProperty | LineProperty | PaddingSizeProperty | ShapeSizeProperty | TextSizeProperty | MetadataAttribute | NotationProperty | NotesProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | ViewStringProperty | BorderProperty | MultipleProperty | OpacityProperty | ShapeProperty | ViewRuleGlobalPredicateRef | ViewRuleGroup | ViewRulePredicate | SpecificationRelationshipKind | GlobalStyle | SpecificationColor | NavigateToProperty | DynamicViewStep | ElementRef | DeploymentRelation | Tags | SpecificationDeploymentNodeKind | DynamicViewParallelSteps | GlobalDynamicPredicateGroup | Relation | SpecificationElementKind | Globals | GlobalPredicateGroup | GlobalStyleGroup | SpecificationTag | ImportsFromPoject | SpecificationRule;
@@ -16981,102 +15483,1637 @@ interface ParsedAstElementView {
     rules: c4.ElementViewRule[];
     manualLayout?: c4.ViewManualLayout;
 }
-interface ParsedAstDynamicView {
-    id: c4.ViewId;
-    astPath: string;
-    title: string | null;
-    description: c4.MarkdownOrString | null;
-    tags: c4.NonEmptyArray<c4.Tag> | null;
-    links: c4.NonEmptyArray<c4.Link> | null;
-    steps: c4.DynamicViewStepOrParallel[];
-    rules: Array<c4.DynamicViewRule>;
-    manualLayout?: c4.ViewManualLayout;
+interface ParsedAstDynamicView {
+    id: c4.ViewId;
+    astPath: string;
+    title: string | null;
+    description: c4.MarkdownOrString | null;
+    tags: c4.NonEmptyArray<c4.Tag> | null;
+    links: c4.NonEmptyArray<c4.Link> | null;
+    steps: c4.DynamicViewStepOrParallel[];
+    rules: Array<c4.DynamicViewRule>;
+    manualLayout?: c4.ViewManualLayout;
+}
+interface ParsedAstDeploymentView {
+    id: c4.ViewId;
+    astPath: string;
+    title: string | null;
+    description: c4.MarkdownOrString | null;
+    tags: c4.NonEmptyArray<c4.Tag> | null;
+    links: c4.NonEmptyArray<c4.Link> | null;
+    rules: Array<c4.DeploymentViewRule>;
+}
+type ParsedAstView = ParsedAstElementView | ParsedAstDynamicView | ParsedAstDeploymentView;
+interface AstNodeDescriptionWithFqn extends AstNodeDescription {
+    likec4ProjectId: c4.ProjectId;
+    id: c4.Fqn;
+}
+type LikeC4AstNode = ValueOf<ConditionalPick<LikeC4AstType, AstNode>>;
+type LikeC4DocumentDiagnostic = Diagnostic & DiagnosticInfo<LikeC4AstNode>;
+interface LikeC4DocumentProps {
+    diagnostics?: Array<LikeC4DocumentDiagnostic>;
+    c4Specification?: ParsedAstSpecification;
+    c4Elements?: ParsedAstElement[];
+    c4ExtendElements?: ParsedAstExtend[];
+    c4ExtendDeployments?: ParsedAstExtend[];
+    c4Relations?: ParsedAstRelation[];
+    c4Globals?: ParsedAstGlobals;
+    c4Views?: ParsedAstView[];
+    c4Deployments?: ParsedAstDeployment[];
+    c4DeploymentRelations?: ParsedAstDeploymentRelation[];
+    c4Imports?: MultiMap$1<c4.ProjectId, c4.Fqn, Set<c4.Fqn>>;
+}
+type LikeC4GrammarDocument = Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>;
+interface LikeC4LangiumDocument extends LikeC4GrammarDocument, LikeC4DocumentProps {
+    likec4ProjectId: c4.ProjectId;
+}
+interface ParsedLikeC4LangiumDocument extends LikeC4GrammarDocument, Required<LikeC4DocumentProps> {
+    likec4ProjectId: c4.ProjectId;
+}
+
+declare class LikeC4NameProvider extends DefaultNameProvider {
+    protected services: LikeC4Services;
+    constructor(services: LikeC4Services);
+    getNameStrict(node: AstNode): string;
+    getName(node: AstNode): string | undefined;
+    getNameNode(node: AstNode): CstNode | undefined;
+}
+
+type ElementsContainer = Model | ElementBody | ExtendElementBody;
+type DeploymentsContainer = ModelDeployments | DeploymentNodeBody | ExtendDeploymentBody | DeployedInstanceBody;
+declare class LikeC4ScopeComputation extends DefaultScopeComputation {
+    constructor(services: LikeC4Services);
+    computeExports(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<AstNodeDescription[]>;
+    private exportViews;
+    private exportGlobals;
+    private exportModel;
+    private exportLibrary;
+    private exportSpecification;
+    private exportDeployments;
+    computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<PrecomputedScopes>;
+    protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
+    protected processDeployments(container: DeploymentsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
+}
+
+declare class IndexManager extends DefaultIndexManager {
+    protected services: LikeC4SharedServices;
+    constructor(services: LikeC4SharedServices);
+    updateContent(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void>;
+    projectElements(projectId: ProjectId, nodeType?: string, uris?: Set<string>): Stream<AstNodeDescription>;
+}
+
+declare class LangiumDocuments extends DefaultLangiumDocuments {
+    protected services: LikeC4SharedServices;
+    constructor(services: LikeC4SharedServices);
+    /**
+     * Returns all user documents, excluding built-in documents.
+     */
+    get allExcludingBuiltin(): Stream<LikeC4LangiumDocument>;
+    projectDocuments(projectId: ProjectId): Stream<LikeC4LangiumDocument>;
+    groupedByProject(): Record<ProjectId, NonEmptyArray<LikeC4LangiumDocument>>;
+    resetProjectIds(): void;
+}
+
+/**
+ * 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 readonly [
+    BaseSchema<unknown, unknown, BaseIssue<unknown>>,
+    ...PipeItem<any, unknown, BaseIssue<unknown>>[]
+]> = Omit<FirstTupleItem<TPipe>, 'pipe' | '~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 readonly [
+    (BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>),
+    ...(PipeItem<any, unknown, BaseIssue<unknown>> | PipeItemAsync<any, unknown, BaseIssue<unknown>>)[]
+]> = Omit<FirstTupleItem<TPipe>, 'async' | 'pipe' | '~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> = {
+    [TKey in keyof TObject]?: unknown;
+} & Omit<TObject, TKeys> & Partial<Pick<TObject, TKeys>>;
+/**
+ * Extracts first tuple item.
+ */
+type FirstTupleItem<TTuple extends readonly [unknown, ...unknown[]]> = TTuple[0];
+/**
+ * Extracts last tuple item.
+ */
+type LastTupleItem<TTuple extends readonly [unknown, ...unknown[]]> = TTuple[TTuple extends readonly [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}"`;
 }
-interface ParsedAstDeploymentView {
-    id: c4.ViewId;
-    astPath: string;
-    title: string | null;
-    description: c4.MarkdownOrString | null;
-    tags: c4.NonEmptyArray<c4.Tag> | null;
-    links: c4.NonEmptyArray<c4.Link> | null;
-    rules: Array<c4.DeploymentViewRule>;
+
+/**
+ * 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;
 }
-type ParsedAstView = ParsedAstElementView | ParsedAstDynamicView | ParsedAstDeploymentView;
-interface AstNodeDescriptionWithFqn extends AstNodeDescription {
-    likec4ProjectId: c4.ProjectId;
-    id: c4.Fqn;
+/**
+ * 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;
 }
-type LikeC4AstNode = ValueOf<ConditionalPick<LikeC4AstType, AstNode>>;
-type LikeC4DocumentDiagnostic = Diagnostic & DiagnosticInfo<LikeC4AstNode>;
-interface LikeC4DocumentProps {
-    diagnostics?: Array<LikeC4DocumentDiagnostic>;
-    c4Specification?: ParsedAstSpecification;
-    c4Elements?: ParsedAstElement[];
-    c4ExtendElements?: ParsedAstExtend[];
-    c4ExtendDeployments?: ParsedAstExtend[];
-    c4Relations?: ParsedAstRelation[];
-    c4Globals?: ParsedAstGlobals;
-    c4Views?: ParsedAstView[];
-    c4Deployments?: ParsedAstDeployment[];
-    c4DeploymentRelations?: ParsedAstDeploymentRelation[];
-    c4Imports?: MultiMap$1<c4.ProjectId, c4.Fqn, Set<c4.Fqn>>;
+/**
+ * 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;
 }
-type LikeC4GrammarDocument = Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>;
-interface LikeC4LangiumDocument extends LikeC4GrammarDocument, LikeC4DocumentProps {
-    likec4ProjectId: c4.ProjectId;
+/**
+ * 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';
 }
-interface ParsedLikeC4LangiumDocument extends LikeC4GrammarDocument, Required<LikeC4DocumentProps> {
-    likec4ProjectId: c4.ProjectId;
+/**
+ * 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>;
+/**
+ * Content input type.
+ */
+type ContentInput = string | MaybeReadonly<unknown[]>;
+/**
+ * Content requirement type.
+ */
+type ContentRequirement<TInput extends ContentInput> = TInput extends readonly unknown[] ? TInput[number] : TInput;
+/**
+ * Length input type.
+ */
+type LengthInput = string | ArrayLike<unknown>;
 
-declare class LikeC4NameProvider extends DefaultNameProvider {
-    protected services: LikeC4Services;
-    constructor(services: LikeC4Services);
-    getNameStrict(node: AstNode): string;
-    getName(node: AstNode): string | undefined;
-    getNameNode(node: AstNode): CstNode | undefined;
+/**
+ * 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>;
 
-type ElementsContainer = Model | ElementBody | ExtendElementBody;
-type DeploymentsContainer = ModelDeployments | DeploymentNodeBody | ExtendDeploymentBody | DeployedInstanceBody;
-declare class LikeC4ScopeComputation extends DefaultScopeComputation {
-    constructor(services: LikeC4Services);
-    computeExports(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<AstNodeDescription[]>;
-    private exportViews;
-    private exportGlobals;
-    private exportModel;
-    private exportLibrary;
-    private exportSpecification;
-    private exportDeployments;
-    computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<PrecomputedScopes>;
-    protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
-    protected processDeployments(container: DeploymentsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
+/**
+ * Excludes issue interface.
+ */
+interface ExcludesIssue<TInput extends ContentInput, TRequirement extends ContentRequirement<TInput>> extends BaseIssue<TInput> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'validation';
+    /**
+     * The issue type.
+     */
+    readonly type: 'excludes';
+    /**
+     * The expected property.
+     */
+    readonly expected: string;
+    /**
+     * The content to be excluded.
+     */
+    readonly requirement: TRequirement;
+}
+/**
+ * Excludes action interface.
+ */
+interface ExcludesAction<TInput extends ContentInput, TRequirement extends ContentRequirement<TInput>, TMessage extends ErrorMessage<ExcludesIssue<TInput, TRequirement>> | undefined> extends BaseValidation<TInput, TInput, ExcludesIssue<TInput, TRequirement>> {
+    /**
+     * The action type.
+     */
+    readonly type: 'excludes';
+    /**
+     * The action reference.
+     */
+    readonly reference: typeof excludes;
+    /**
+     * The expected property.
+     */
+    readonly expects: string;
+    /**
+     * The content to be excluded.
+     */
+    readonly requirement: TRequirement;
+    /**
+     * The error message.
+     */
+    readonly message: TMessage;
 }
+/**
+ * Creates an excludes validation action.
+ *
+ * @param requirement The content to be excluded.
+ *
+ * @returns An excludes action.
+ */
+declare function excludes<TInput extends ContentInput, const TRequirement extends ContentRequirement<TInput>>(requirement: TRequirement): ExcludesAction<TInput, TRequirement, undefined>;
+/**
+ * Creates an excludes validation action.
+ *
+ * @param requirement The content to be excluded.
+ * @param message The error message.
+ *
+ * @returns An excludes action.
+ */
+declare function excludes<TInput extends ContentInput, const TRequirement extends ContentRequirement<TInput>, const TMessage extends ErrorMessage<ExcludesIssue<TInput, TRequirement>> | undefined>(requirement: TRequirement, message: TMessage): ExcludesAction<TInput, TRequirement, TMessage>;
 
-declare class IndexManager extends DefaultIndexManager {
-    protected services: LikeC4SharedServices;
-    constructor(services: LikeC4SharedServices);
-    updateContent(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void>;
-    projectElements(projectId: ProjectId, nodeType?: string, uris?: Set<string>): Stream<AstNodeDescription>;
+/**
+ * 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>;
 
-declare class LangiumDocuments extends DefaultLangiumDocuments {
-    protected services: LikeC4SharedServices;
-    constructor(services: LikeC4SharedServices);
+/**
+ * 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> {
     /**
-     * Returns all user documents, excluding built-in documents.
+     * The action type.
      */
-    get allExcludingBuiltin(): Stream<LikeC4LangiumDocument>;
-    projectDocuments(projectId: ProjectId): Stream<LikeC4LangiumDocument>;
-    groupedByProject(): Record<ProjectId, NonEmptyArray<LikeC4LangiumDocument>>;
+    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>;
 
-interface Project {
+declare const ProjectConfig: ObjectSchema<{
+    readonly name: SchemaWithPipe<readonly [StringSchema<undefined>, NonEmptyAction<string, "Project name cannot be empty">, ExcludesAction<string, "default", "Project name cannot be \"default\"">, ExcludesAction<string, ".", "Project name cannot contain \".\", try to use A-z, 0-9, _ and -">, ExcludesAction<string, "@", "Project name cannot contain \"@\", try to use A-z, 0-9, _ and -">, ExcludesAction<string, "#", "Project name cannot contain \"#\", try to use A-z, 0-9, _ and -">, DescriptionAction<string, "Project name, must be unique in the workspace">]>;
+    readonly title: OptionalSchema<SchemaWithPipe<readonly [StringSchema<undefined>, NonEmptyAction<string, "Project title cannot be empty if specified">, DescriptionAction<string, "A human readable title for the project">]>, undefined>;
+    readonly contactPerson: OptionalSchema<SchemaWithPipe<readonly [StringSchema<undefined>, NonEmptyAction<string, "Contact person cannot be empty if specified">, DescriptionAction<string, "A person who has been involved in creating or maintaining this project">]>, undefined>;
+    readonly exclude: OptionalSchema<SchemaWithPipe<readonly [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>;
+
+/**
+ * A tagged string that represents a project folder.
+ * Always has trailing slash.
+ */
+type ProjectFolder = Tagged<string, 'ProjectFolder'>;
+declare function ProjectFolder(folder: URI | string): ProjectFolder;
+interface ProjectData {
     id: ProjectId;
     config: ProjectConfig;
-    folder: string;
+    folder: ProjectFolder;
+    folderUri: URI;
     exclude?: picomatch.Matcher;
 }
+interface Project {
+    id: ProjectId;
+    folderUri: URI;
+    config: ProjectConfig;
+}
 declare class ProjectsManager {
     protected services: LikeC4SharedServices;
     /**
@@ -17095,7 +17132,9 @@ declare class ProjectsManager {
      * This ensures that the most specific project is used for a document.
      */
     private _projects;
+    private excludedDocuments;
     private defaultGlobalProject;
+    private reloadProjectsLimiter;
     constructor(services: LikeC4SharedServices);
     /**
      * Returns:
@@ -17105,30 +17144,33 @@ declare class ProjectsManager {
      */
     get defaultProjectId(): ProjectId | undefined;
     get all(): NonEmptyReadonlyArray<ProjectId>;
-    getProject(arg: ProjectId | LangiumDocument): {
-        id: ProjectId;
-        folder: URI;
-        config: Readonly<ProjectConfig>;
-    };
+    getProject(arg: ProjectId | LangiumDocument): Project;
     ensureProjectId(projectId?: ProjectId | undefined): ProjectId;
     hasMultipleProjects(): boolean;
-    checkIfExcluded(documentUri: URI): boolean;
-    isConfigFile(entry: FileSystemNode): boolean;
+    checkIfExcluded(document: LangiumDocument | URI | string): boolean;
+    /**
+     * Checks if it is a config file and it is not excluded by default exclude pattern
+     *
+     * @param entry The file system entry to check
+     */
+    isConfigFile(entry: URI): boolean;
     /**
      * Checks if the provided file system entry is a valid project config file.
      *
      * @param entry The file system entry to check
      */
-    loadConfigFile(entry: FileSystemNode): Promise<Project | undefined>;
-    registerProject(configFile: URI): Promise<Project>;
+    loadConfigFile(entry: FileSystemNode): Promise<ProjectData | undefined>;
+    registerProject(configFile: URI): Promise<ProjectData>;
     registerProject(opts: {
         config: ProjectConfig;
         folderUri: URI | string;
-    }): Promise<Project>;
+    }): Promise<ProjectData>;
     belongsTo(document: LangiumDocument | URI | string): ProjectId;
-    protected findProjectForDocument(documentUri: string): Omit<Project, 'folder'>;
-    private _mappingsToProject;
-    protected get mappingsToProject(): WorkspaceCache<string, Omit<Project, 'folder'>>;
+    reloadProjects(token?: CancellationToken): Promise<void>;
+    protected uniqueProjectId(name: string): ProjectId;
+    protected resetProjectIds(): void;
+    protected findProjectForDocument(documentUri: string): any;
+    protected get mappingsToProject(): WorkspaceCache<string, Pick<ProjectData, 'id' | 'config' | 'exclude'>>;
 }
 
 declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
@@ -17299,7 +17341,7 @@ declare class BaseParser {
     constructor(services: LikeC4Services, doc: ParsedLikeC4LangiumDocument);
     get project(): {
         id: c4.ProjectId;
-        folder: URI;
+        folderUri: URI;
         config: Readonly<ProjectConfig>;
     };
     resolveFqn(node: FqnReferenceable): c4.Fqn;
@@ -17392,7 +17434,7 @@ declare const DocumentParserFromMixins: {
         readonly doc: ParsedLikeC4LangiumDocument;
         get project(): {
             id: ProjectId;
-            folder: ProjectId;
+            folderUri: ProjectId;
             config: Readonly<ProjectConfig>;
         };
         resolveFqn(node: FqnReferenceable): ProjectId;
@@ -17485,7 +17527,7 @@ declare const DocumentParserFromMixins: {
         readonly doc: ParsedLikeC4LangiumDocument;
         get project(): {
             id: ProjectId;
-            folder: ProjectId;
+            folderUri: ProjectId;
             config: Readonly<ProjectConfig>;
         };
         resolveFqn(node: FqnReferenceable): ProjectId;
@@ -17540,7 +17582,7 @@ declare const DocumentParserFromMixins: {
         readonly doc: ParsedLikeC4LangiumDocument;
         get project(): {
             id: ProjectId;
-            folder: ProjectId;
+            folderUri: ProjectId;
             config: Readonly<ProjectConfig>;
         };
         resolveFqn(node: FqnReferenceable): ProjectId;
@@ -17609,7 +17651,7 @@ declare const DocumentParserFromMixins: {
         readonly doc: ParsedLikeC4LangiumDocument;
         get project(): {
             id: ProjectId;
-            folder: ProjectId;
+            folderUri: ProjectId;
             config: Readonly<ProjectConfig>;
         };
         resolveFqn(node: FqnReferenceable): ProjectId;
@@ -17671,7 +17713,7 @@ declare const DocumentParserFromMixins: {
         readonly doc: ParsedLikeC4LangiumDocument;
         get project(): {
             id: ProjectId;
-            folder: ProjectId;
+            folderUri: ProjectId;
             config: Readonly<ProjectConfig>;
         };
         resolveFqn(node: FqnReferenceable): ProjectId;
@@ -17741,7 +17783,7 @@ declare const DocumentParserFromMixins: {
         readonly doc: ParsedLikeC4LangiumDocument;
         get project(): {
             id: ProjectId;
-            folder: ProjectId;
+            folderUri: ProjectId;
             config: Readonly<ProjectConfig>;
         };
         resolveFqn(node: FqnReferenceable): ProjectId;
@@ -17804,7 +17846,7 @@ declare const DocumentParserFromMixins: {
         readonly doc: ParsedLikeC4LangiumDocument;
         get project(): {
             id: ProjectId;
-            folder: ProjectId;
+            folderUri: ProjectId;
             config: Readonly<ProjectConfig>;
         };
         resolveFqn(node: FqnReferenceable): ProjectId;
@@ -17847,7 +17889,7 @@ declare const DocumentParserFromMixins: {
         readonly doc: ParsedLikeC4LangiumDocument;
         get project(): {
             id: ProjectId;
-            folder: ProjectId;
+            folderUri: ProjectId;
             config: Readonly<ProjectConfig>;
         };
         resolveFqn(node: FqnReferenceable): ProjectId;
@@ -17905,7 +17947,7 @@ declare const DocumentParserFromMixins: {
         readonly doc: ParsedLikeC4LangiumDocument;
         get project(): {
             id: ProjectId;
-            folder: ProjectId;
+            folderUri: ProjectId;
             config: Readonly<ProjectConfig>;
         };
         resolveFqn(node: FqnReferenceable): ProjectId;
@@ -18054,13 +18096,28 @@ interface LikeC4LanguageServices {
     readonly builder: LikeC4ModelBuilder;
     readonly workspaceUri: URI;
     readonly projectsManager: ProjectsManager;
+    /**
+     * Returns all projects with relevant documents
+     */
     projects(): NonEmptyArray<{
         id: ProjectId;
         folder: URI;
-        config: ProjectConfig;
+        title: string;
         documents: NonEmptyArray<URI> | null;
     }>;
-    diagrams(): Promise<DiagramView[]>;
+    /**
+     * Returns project by ID
+     */
+    project(projectId: ProjectId): {
+        id: ProjectId;
+        folder: URI;
+        title: string;
+    };
+    /**
+     * Returns diagrams (i.e. views with layout computed) for the specified project
+     * If no project is specified, returns diagrams for default project
+     */
+    diagrams(project?: ProjectId | undefined): Promise<DiagramView[]>;
     computedModel(project?: ProjectId | undefined): Promise<LikeC4Model.Computed>;
     layoutedModel(project?: ProjectId | undefined): Promise<LikeC4Model.Layouted>;
     getErrors(): Array<{
@@ -18069,11 +18126,21 @@ interface LikeC4LanguageServices {
         range: Range$1;
         sourceFsPath: string;
     }>;
+    /**
+     * Notifies the language server about changes in the workspace
+     */
     notifyUpdate(update: {
         changed?: string;
         removed?: string;
     }): Promise<boolean>;
+    /**
+     * Returns the location of the specified element, relation, view or deployment element
+     */
     locate(params: Locate.Params): Locate.Res;
+    /**
+     * Checks if the specified document should be excluded from processing.
+     */
+    isExcluded(doc: LangiumDocument): boolean;
 }
 
 declare class LikeC4CodeLensProvider implements CodeLensProvider {
@@ -47589,6 +47656,9 @@ interface LikeC4AddedServices {
         DocumentationProvider: LikeC4DocumentationProvider;
     };
     ValidatedWorkspaceCache: WorkspaceCache<string, any>;
+    validation: {
+        DocumentValidator: LikeC4DocumentValidator;
+    };
     Rpc: Rpc;
     mcp: {
         Server: LikeC4MCPServer;