likec4 1.32.1 → 1.32.2

package/dist/shared/{likec4.CVzYPnDX.d.mts → likec4.BaQDJZ_m.d.mts}

@@ -1,6 +1,6 @@
-import * as c4 from '@likec4/core';
-import { Fqn, EdgeId, AnyAux, ComputedView, Specification, DiagramView, MultiMap as MultiMap$1, ProjectId, NonEmptyArray, NonEmptyReadonlyArray, ViewId, RelationId, DeploymentFqn, ViewChange } from '@likec4/core';
 import { Tagged, ValueOf, ConditionalPick, Writable, Simplify, MergeExclusive } from 'type-fest';
+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.0/node_modules/@types/picomatch/posix.d.ts';
 import { ProjectId as ProjectId$1, Fqn as Fqn$1 } from '@likec4/core/types';
@@ -12066,26 +12066,60 @@ interface GraphvizPort {
     layoutJson(dot: DotSource): Promise<string>;
     svg(dot: DotSource): Promise<string>;
 }
-type Params<A extends AnyAux = AnyAux> = {
+type LayoutTaskParams<A extends aux.Any = aux.Any> = {
     view: ComputedView<A>;
     specification: Specification<A>;
 };
-type LayoutResult = {
+type LayoutResult<A extends aux.Any = aux.Any> = {
     dot: DotSource;
-    diagram: DiagramView;
+    diagram: DiagramView<A>;
 };
 declare class GraphvizLayouter {
     private graphviz;
-    constructor(graphviz: GraphvizPort);
-    get port(): GraphvizPort;
+    constructor(graphviz?: GraphvizPort);
+    get graphvizPort(): GraphvizPort;
     changePort(graphviz: GraphvizPort): void;
     dotToJson(dot: DotSource): Promise<GraphvizJson>;
-    layout<A extends AnyAux>(params: Params<A>): Promise<LayoutResult>;
-    svg<A extends AnyAux>(params: Params<A>): Promise<{
+    layout<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<LayoutResult<A>>;
+    svg<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<{
         svg: string;
         dot: DotSource;
     }>;
-    dot<A extends AnyAux>(params: Params<A>): Promise<DotSource>;
+    dot<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<DotSource>;
+}
+
+declare class QueueGraphvizLayoter extends GraphvizLayouter {
+    private queue;
+    private isProcessingBatch;
+    constructor(options?: {
+        graphviz?: GraphvizPort;
+        /**
+        Concurrency limit.
+    
+        Minimum: `1`.
+    
+        @default 2
+        */
+        concurrency?: number;
+        /**
+        Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
+        @default 20_000
+        */
+        timeout?: number;
+        /**
+        Whether or not a timeout is considered an exception.
+        @default true
+        */
+        throwOnTimeout?: boolean;
+    });
+    private runInQueue;
+    changePort(graphvizPort: GraphvizPort): void;
+    layout<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<LayoutResult<A>>;
+    batchLayout<A extends AnyAux>(params: {
+        batch: LayoutTaskParams<A>[];
+        onSuccess?: (task: LayoutTaskParams<A>, result: LayoutResult<A>) => void;
+        onError?: (task: LayoutTaskParams<A>, error: unknown) => void;
+    }): Promise<LayoutResult<A>[]>;
 }
 
 interface WorkDoneProgressReporter {
@@ -14214,7 +14248,7 @@ type SchemaWithFallbackAsync<TSchema extends BaseSchema<unknown, unknown, BaseIs
 type SchemaWithPipe<TPipe extends readonly [
     BaseSchema<unknown, unknown, BaseIssue<unknown>>,
     ...PipeItem<any, unknown, BaseIssue<unknown>>[]
-]> = Omit<FirstTupleItem<TPipe>, '~standard' | '~run' | '~types'> & {
+]> = Omit<FirstTupleItem<TPipe>, 'pipe' | '~standard' | '~run' | '~types'> & {
     /**
      * The pipe items.
      */
@@ -14254,7 +14288,7 @@ type SchemaWithPipe<TPipe extends readonly [
 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' | '~standard' | '~run' | '~types'> & {
+]> = Omit<FirstTupleItem<TPipe>, 'async' | 'pipe' | '~standard' | '~run' | '~types'> & {
     /**
      * The pipe items.
      */
@@ -14723,15 +14757,15 @@ type Prettify<TObject> = {
 /**
  * Marks specific keys as optional.
  */
-type MarkOptional<TObject, TKeys extends keyof TObject> = Partial<TObject> & Required<Omit<TObject, TKeys>>;
+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];
 
@@ -15489,6 +15523,14 @@ declare function string(): StringSchema<undefined>;
  * @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.
  */
@@ -15520,6 +15562,70 @@ interface DescriptionAction<TInput, TDescription extends string> extends BaseMet
  */
 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;
+}
+/**
+ * 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>;
+
 /**
  * Non empty issue interface.
  */
@@ -15602,8 +15708,8 @@ interface ReadonlyAction<TInput> extends BaseTransformation<TInput, ReadonlyOutp
 declare function readonly<TInput>(): ReadonlyAction<TInput>;
 
 declare const ProjectConfig: ObjectSchema<{
-    readonly name: SchemaWithPipe<readonly [SchemaWithPipe<readonly [StringSchema<undefined>, NonEmptyAction<string, undefined>]>, DescriptionAction<string, "Project name, must be unique in the workspace">]>;
-    readonly contactPerson: OptionalSchema<SchemaWithPipe<readonly [SchemaWithPipe<readonly [StringSchema<undefined>, NonEmptyAction<string, undefined>]>, DescriptionAction<string, "A person who has been involved in creating or maintaining this project">]>, undefined>;
+    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 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>;
@@ -15778,6 +15884,7 @@ interface DeploymentRelation extends AstNode {
     readonly $container: DeployedInstanceBody | DeploymentNodeBody | ExtendDeploymentBody | ModelDeployments;
     readonly $type: 'DeploymentRelation';
     body?: DeploymentRelationBody;
+    description?: string;
     dotKind?: RelationKindDotRef;
     kind?: Reference<RelationshipKind>;
     source?: FqnRef;
@@ -16245,6 +16352,7 @@ interface Relation extends AstNode {
     readonly $container: ElementBody | ExtendElementBody | Model;
     readonly $type: 'Relation';
     body?: RelationBody;
+    description?: string;
     dotKind?: RelationKindDotRef;
     kind?: Reference<RelationshipKind>;
     source?: FqnRef;
@@ -16993,7 +17101,6 @@ declare class ProjectsManager {
      * Checks if the provided file system entry is a valid project config file.
      *
      * @param entry The file system entry to check
-     * @returns {boolean} Returns true if the entry is a valid config file, false otherwise.
      */
     loadConfigFile(entry: FileSystemNode): Promise<Project | undefined>;
     registerProject(configFile: URI): Promise<Project>;
@@ -17827,13 +17934,16 @@ type Primitive$1 = string | number | symbol | bigint | boolean | null | undefine
 declare namespace util {
     type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
     export type isAny<T> = 0 extends 1 & T ? true : false;
-    export const assertEqual: <A, B>(val: AssertEqual<A, B>) => AssertEqual<A, B>;
+    export const assertEqual: <A, B>(_: AssertEqual<A, B>) => void;
     export function assertIs<T>(_arg: T): void;
     export function assertNever(_x: never): never;
     export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
     export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
     export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
     export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
+    export type InexactPartial<T> = {
+        [k in keyof T]?: T[k] | undefined;
+    };
     export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k; };
     export const getValidEnumValues: (obj: any) => any[];
     export const objectValues: (obj: any) => any[];
@@ -17884,24 +17994,24 @@ declare namespace objectUtil {
 }
 declare const ZodParsedType: {
     string: "string";
-    number: "number";
-    bigint: "bigint";
-    boolean: "boolean";
-    symbol: "symbol";
-    undefined: "undefined";
-    object: "object";
-    function: "function";
-    map: "map";
     nan: "nan";
+    number: "number";
     integer: "integer";
     float: "float";
+    boolean: "boolean";
     date: "date";
+    bigint: "bigint";
+    symbol: "symbol";
+    function: "function";
+    undefined: "undefined";
     null: "null";
     array: "array";
+    object: "object";
     unknown: "unknown";
     promise: "promise";
     void: "void";
     never: "never";
+    map: "map";
     set: "set";
 };
 type ZodParsedType = keyof typeof ZodParsedType;
@@ -17934,7 +18044,7 @@ declare const ZodIssueCode: {
 type ZodIssueCode = keyof typeof ZodIssueCode;
 type ZodIssueBase = {
     path: (string | number)[];
-    message?: string;
+    message?: string | undefined;
 };
 interface ZodInvalidTypeIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_type;
@@ -17976,7 +18086,7 @@ interface ZodInvalidDateIssue extends ZodIssueBase {
 }
 type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "cidr" | "base64" | "jwt" | "base64url" | {
     includes: string;
-    position?: number;
+    position?: number | undefined;
 } | {
     startsWith: string;
 } | {
@@ -18018,7 +18128,7 @@ interface ZodCustomIssue extends ZodIssueBase {
 }
 type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
 type ZodIssue = ZodIssueOptionalMessage & {
-    fatal?: boolean;
+    fatal?: boolean | undefined;
     message: string;
 };
 type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? {
@@ -18051,7 +18161,7 @@ declare class ZodError<T = any> extends Error {
 type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
 type IssueData = stripPath<ZodIssueOptionalMessage> & {
     path?: (string | number)[];
-    fatal?: boolean;
+    fatal?: boolean | undefined;
 };
 type ErrorMapCtx = {
     defaultError: string;
@@ -18071,11 +18181,11 @@ type ParsePath = ParsePathComponent[];
 interface ParseContext {
     readonly common: {
         readonly issues: ZodIssue[];
-        readonly contextualErrorMap?: ZodErrorMap;
+        readonly contextualErrorMap?: ZodErrorMap | undefined;
         readonly async: boolean;
     };
     readonly path: ParsePath;
-    readonly schemaErrorMap?: ZodErrorMap;
+    readonly schemaErrorMap?: ZodErrorMap | undefined;
     readonly parent: ParseContext | null;
     readonly data: any;
     readonly parsedType: ZodParsedType;
@@ -18129,7 +18239,7 @@ declare namespace enumUtil {
 
 declare namespace errorUtil {
     type ErrMessage = string | {
-        message?: string;
+        message?: string | undefined;
     };
     const errToObj: (message?: ErrMessage) => {
         message?: string | undefined;
@@ -18262,15 +18372,15 @@ type output<T extends ZodType<any, any, any>> = T["_output"];
 
 type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
 interface ZodTypeDef {
-    errorMap?: ZodErrorMap;
-    description?: string;
+    errorMap?: ZodErrorMap | undefined;
+    description?: string | undefined;
 }
 type RawCreateParams = {
-    errorMap?: ZodErrorMap;
-    invalid_type_error?: string;
-    required_error?: string;
-    message?: string;
-    description?: string;
+    errorMap?: ZodErrorMap | undefined;
+    invalid_type_error?: string | undefined;
+    required_error?: string | undefined;
+    message?: string | undefined;
+    description?: string | undefined;
 } | undefined;
 type SafeParseSuccess<Output> = {
     success: true;
@@ -18299,13 +18409,13 @@ declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef
     };
     _parseSync(input: ParseInput): SyncParseReturnType<Output>;
     _parseAsync(input: ParseInput): AsyncParseReturnType<Output>;
-    parse(data: unknown, params?: Partial<ParseParams>): Output;
-    safeParse(data: unknown, params?: Partial<ParseParams>): SafeParseReturnType<Input, Output>;
+    parse(data: unknown, params?: util.InexactPartial<ParseParams>): Output;
+    safeParse(data: unknown, params?: util.InexactPartial<ParseParams>): SafeParseReturnType<Input, Output>;
     "~validate"(data: unknown): StandardSchemaV1.Result<Output> | Promise<StandardSchemaV1.Result<Output>>;
-    parseAsync(data: unknown, params?: Partial<ParseParams>): Promise<Output>;
-    safeParseAsync(data: unknown, params?: Partial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
+    parseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<Output>;
+    safeParseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
     /** Alias of safeParseAsync */
-    spa: (data: unknown, params?: Partial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;
+    spa: (data: unknown, params?: util.InexactPartial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;
     refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;
     refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
     refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;
@@ -18341,99 +18451,99 @@ type IpVersion = "v4" | "v6";
 type ZodStringCheck = {
     kind: "min";
     value: number;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "max";
     value: number;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "length";
     value: number;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "email";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "url";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "emoji";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "uuid";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "nanoid";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "cuid";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "includes";
     value: string;
-    position?: number;
-    message?: string;
+    position?: number | undefined;
+    message?: string | undefined;
 } | {
     kind: "cuid2";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "ulid";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "startsWith";
     value: string;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "endsWith";
     value: string;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "regex";
     regex: RegExp;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "trim";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "toLowerCase";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "toUpperCase";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "jwt";
     alg?: string;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "datetime";
     offset: boolean;
     local: boolean;
     precision: number | null;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "date";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "time";
     precision: number | null;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "duration";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "ip";
-    version?: IpVersion;
-    message?: string;
+    version?: IpVersion | undefined;
+    message?: string | undefined;
 } | {
     kind: "cidr";
-    version?: IpVersion;
-    message?: string;
+    version?: IpVersion | undefined;
+    message?: string | undefined;
 } | {
     kind: "base64";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "base64url";
-    message?: string;
+    message?: string | undefined;
 };
 interface ZodStringDef extends ZodTypeDef {
     checks: ZodStringCheck[];
@@ -18456,15 +18566,15 @@ declare class ZodString extends ZodType<string, ZodStringDef, string> {
     base64url(message?: errorUtil.ErrMessage): ZodString;
     jwt(options?: {
         alg?: string;
-        message?: string;
+        message?: string | undefined;
     }): ZodString;
     ip(options?: string | {
         version?: IpVersion;
-        message?: string;
+        message?: string | undefined;
     }): ZodString;
     cidr(options?: string | {
         version?: IpVersion;
-        message?: string;
+        message?: string | undefined;
     }): ZodString;
     datetime(options?: string | {
         message?: string | undefined;
@@ -18521,22 +18631,22 @@ type ZodNumberCheck = {
     kind: "min";
     value: number;
     inclusive: boolean;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "max";
     value: number;
     inclusive: boolean;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "int";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "multipleOf";
     value: number;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "finite";
-    message?: string;
+    message?: string | undefined;
 };
 interface ZodNumberDef extends ZodTypeDef {
     checks: ZodNumberCheck[];
@@ -18593,15 +18703,15 @@ interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     typeName: ZodFirstPartyTypeKind.ZodArray;
     exactLength: {
         value: number;
-        message?: string;
+        message?: string | undefined;
     } | null;
     minLength: {
         value: number;
-        message?: string;
+        message?: string | undefined;
     } | null;
     maxLength: {
         value: number;
-        message?: string;
+        message?: string | undefined;
     } | null;
 }
 type ArrayCardinality = "many" | "atleastone";
@@ -18613,7 +18723,7 @@ declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinalit
     max(maxLength: number, message?: errorUtil.ErrMessage): this;
     length(len: number, message?: errorUtil.ErrMessage): this;
     nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
-    static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodArray<T_1, "many">;
+    static create: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
 }
 type UnknownKeysParam = "passthrough" | "strict" | "strip";
 interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
@@ -18698,24 +18808,20 @@ declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysPa
         [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k];
     }>, UnknownKeys, Catchall>;
     keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;
-    static create: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any> extends infer T_2 ? { [k in keyof T_2]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; } : never, baseObjectInputType<T_1> extends infer T_3 ? { [k_1 in keyof T_3]: baseObjectInputType<T_1>[k_1]; } : never>;
-    static strictCreate: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strict", ZodTypeAny, objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any> extends infer T_2 ? { [k in keyof T_2]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; } : never, baseObjectInputType<T_1> extends infer T_3 ? { [k_1 in keyof T_3]: baseObjectInputType<T_1>[k_1]; } : never>;
-    static lazycreate: <T_1 extends ZodRawShape>(shape: () => T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any> extends infer T_2 ? { [k in keyof T_2]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; } : never, baseObjectInputType<T_1> extends infer T_3 ? { [k_1 in keyof T_3]: baseObjectInputType<T_1>[k_1]; } : never>;
+    static create: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
+    static strictCreate: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
+    static lazycreate: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;
 }
 type AnyZodObject = ZodObject<any, any, any>;
 type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
-interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[
-    ZodTypeAny,
-    ZodTypeAny,
-    ...ZodTypeAny[]
-]>> extends ZodTypeDef {
+interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>> extends ZodTypeDef {
     options: T;
     typeName: ZodFirstPartyTypeKind.ZodUnion;
 }
 declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get options(): T;
-    static create: <T_1 extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T_1, params?: RawCreateParams) => ZodUnion<T_1>;
+    static create: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
 }
 type ZodDiscriminatedUnionOption<Discriminator extends string> = ZodObject<{
     [key in Discriminator]: ZodTypeAny;
@@ -18751,7 +18857,7 @@ interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTyp
 }
 declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType<T["_output"] & U["_output"], ZodIntersectionDef<T, U>, T["_input"] & U["_input"]> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <T_1 extends ZodTypeAny, U_1 extends ZodTypeAny>(left: T_1, right: U_1, params?: RawCreateParams) => ZodIntersection<T_1, U_1>;
+    static create: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
 }
 type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
 type AssertArray<T> = T extends any[] ? T : never;
@@ -18768,11 +18874,11 @@ interface ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends
     rest: Rest;
     typeName: ZodFirstPartyTypeKind.ZodTuple;
 }
-declare class ZodTuple<T extends [ZodTypeAny, ...ZodTypeAny[]] | [] = [ZodTypeAny, ...ZodTypeAny[]], Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
+declare class ZodTuple<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get items(): T;
-    rest<Rest extends ZodTypeAny>(rest: Rest): ZodTuple<T, Rest>;
-    static create: <T_1 extends [] | [ZodTypeAny, ...ZodTypeAny[]]>(schemas: T_1, params?: RawCreateParams) => ZodTuple<T_1, null>;
+    rest<RestSchema extends ZodTypeAny>(rest: RestSchema): ZodTuple<T, RestSchema>;
+    static create: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
 }
 interface ZodLiteralDef<T = any> extends ZodTypeDef {
     value: T;
@@ -18781,7 +18887,7 @@ interface ZodLiteralDef<T = any> extends ZodTypeDef {
 declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>, T> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get value(): T;
-    static create: <T_1 extends Primitive$1>(value: T_1, params?: RawCreateParams) => ZodLiteral<T_1>;
+    static create: <Value extends Primitive$1>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;
 }
 type EnumValues<T extends string = string> = readonly [T, ...T[]];
 type Values<T extends EnumValues> = {
@@ -18799,7 +18905,7 @@ type typecast<A, T> = A extends T ? A : never;
 declare function createZodEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: RawCreateParams): ZodEnum<Writeable<T>>;
 declare function createZodEnum<U extends string, T extends [U, ...U[]]>(values: T, params?: RawCreateParams): ZodEnum<T>;
 declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number], ZodEnumDef<T>, T[number]> {
-    #private;
+    _cache: Set<T[number]> | undefined;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get options(): T;
     get enum(): Values<T>;
@@ -18816,7 +18922,7 @@ interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_output"]>, ZodPromiseDef<T>, Promise<T["_input"]>> {
     unwrap(): T;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodPromise<T_1>;
+    static create: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
 }
 type RefinementEffect<T> = {
     type: "refinement";
@@ -18851,7 +18957,7 @@ interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     unwrap(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodOptional<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
 }
 interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
@@ -18860,7 +18966,7 @@ interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     unwrap(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodNullable<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
 }
 interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
@@ -18870,15 +18976,9 @@ interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodDefaultDef<T>, T["_input"] | undefined> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     removeDefault(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params: {
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        message?: string | undefined;
-        description?: string | undefined;
-    } & {
-        default: T_1["_input"] | (() => util.noUndefined<T_1["_input"]>);
-    }) => ZodDefault<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
+        default: Inner["_input"] | (() => util.noUndefined<Inner["_input"]>);
+    }) => ZodDefault<Inner>;
 }
 interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
@@ -18891,15 +18991,9 @@ interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, unknown> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     removeCatch(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params: {
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        message?: string | undefined;
-        description?: string | undefined;
-    } & {
-        catch: T_1["_output"] | (() => T_1["_output"]);
-    }) => ZodCatch<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
+        catch: Inner["_output"] | (() => Inner["_output"]);
+    }) => ZodCatch<Inner>;
 }
 interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
     type: T;
@@ -18922,7 +19016,7 @@ interface ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> extends Zod
 }
 declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType<B["_output"], ZodPipelineDef<A, B>, A["_input"]> {
     _parse(input: ParseInput): ParseReturnType<any>;
-    static create<A extends ZodTypeAny, B extends ZodTypeAny>(a: A, b: B): ZodPipeline<A, B>;
+    static create<ASchema extends ZodTypeAny, BSchema extends ZodTypeAny>(a: ASchema, b: BSchema): ZodPipeline<ASchema, BSchema>;
 }
 type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
     readonly [Symbol.toStringTag]: string;
@@ -18934,7 +19028,7 @@ interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 }
 declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["_output"]>, ZodReadonlyDef<T>, MakeReadonly<T["_input"]>> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodReadonly<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodReadonly<Inner>;
     unwrap(): T;
 }
 declare enum ZodFirstPartyTypeKind {
@@ -37220,6 +37314,8 @@ type RegisteredPrompt = {
 };
 
 interface LikeC4MCPServer {
+    readonly isStarted: boolean;
+    readonly port: number;
     start(port: number): Promise<void>;
     stop(): Promise<void>;
 }
@@ -37367,7 +37463,7 @@ interface LikeC4AddedServices {
     likec4: {
         LanguageServices: LikeC4LanguageServices;
         Views: LikeC4Views;
-        Layouter: GraphvizLayouter;
+        Layouter: QueueGraphvizLayoter;
         DeploymentsIndex: DeploymentsIndex;
         FqnIndex: FqnIndex;
         ModelParser: LikeC4ModelParser;
@@ -37393,4 +37489,4 @@ interface LikeC4AddedServices {
 }
 type LikeC4Services = LangiumServices & LikeC4AddedServices;
 
-export { GraphvizLayouter as G, type LikeC4LanguageServices as L, Range$1 as R, WorkspaceFolder as W, type LikeC4Services as a, type LikeC4Views as b };
+export { type LikeC4LanguageServices as L, Range$1 as R, WorkspaceFolder as W, type LikeC4Services as a, type LikeC4Views as b };