@abco20/btxml-checker 0.1.0

package/dist/types-BgqDzlJ8.d.ts

@@ -0,0 +1,425 @@
+import { D as Diagnostic } from './diagnostic-B5htzyJ9.js';
+import { z } from 'zod';
+
+declare const severitySchema: z.ZodEnum<{
+    error: "error";
+    info: "info";
+    off: "off";
+    warn: "warn";
+}>;
+declare const ruleConfigSchema: z.ZodUnion<readonly [z.ZodEnum<{
+    error: "error";
+    info: "info";
+    off: "off";
+    warn: "warn";
+}>, z.ZodTuple<[z.ZodEnum<{
+    error: "error";
+    info: "info";
+    off: "off";
+    warn: "warn";
+}>, z.ZodRecord<z.ZodString, z.ZodUnknown>], null>]>;
+declare const filesConfigSchema: z.ZodObject<{
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    ignore: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    useGitignore: z.ZodOptional<z.ZodBoolean>;
+    followSymlinks: z.ZodOptional<z.ZodBoolean>;
+    maxSize: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+declare const resolverIncludesConfigSchema: z.ZodObject<{
+    elements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        attribute: z.ZodString;
+        base: z.ZodOptional<z.ZodEnum<{
+            file: "file";
+            "project-root": "project-root";
+        }>>;
+    }, z.core.$strict>>>;
+    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    allowOutsideRoot: z.ZodOptional<z.ZodBoolean>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+    maxFiles: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+declare const resolverConfigSchema: z.ZodObject<{
+    entrypoints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    includes: z.ZodOptional<z.ZodObject<{
+        elements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            attribute: z.ZodString;
+            base: z.ZodOptional<z.ZodEnum<{
+                file: "file";
+                "project-root": "project-root";
+            }>>;
+        }, z.core.$strict>>>;
+        variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        allowOutsideRoot: z.ZodOptional<z.ZodBoolean>;
+        maxDepth: z.ZodOptional<z.ZodNumber>;
+        maxFiles: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    behaviorTreeIds: z.ZodOptional<z.ZodEnum<{
+        "workspace-unique": "workspace-unique";
+        "file-local-first": "file-local-first";
+        "allow-ambiguous": "allow-ambiguous";
+    }>>;
+}, z.core.$strict>;
+declare const modelsConfigSchema: z.ZodObject<{
+    builtins: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "btcpp-v4.6.2": "btcpp-v4.6.2";
+        "btcpp-v4.8.2": "btcpp-v4.8.2";
+        "btcpp-v4.9.0": "btcpp-v4.9.0";
+        "btcpp-v4": "btcpp-v4";
+    }>>>;
+    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    augmentations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    definitions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    inline: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        kind: z.ZodEnum<{
+            Action: "Action";
+            Condition: "Condition";
+            Control: "Control";
+            Decorator: "Decorator";
+            SubTree: "SubTree";
+        }>;
+        ports: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            direction: z.ZodOptional<z.ZodEnum<{
+                input: "input";
+                output: "output";
+                inout: "inout";
+            }>>;
+            type: z.ZodOptional<z.ZodString>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+declare const linterSuppressionsConfigSchema: z.ZodObject<{
+    inline: z.ZodOptional<z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+    }>>;
+}, z.core.$strict>;
+declare const linterConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+        error: "error";
+        info: "info";
+        off: "off";
+        warn: "warn";
+    }>, z.ZodTuple<[z.ZodEnum<{
+        error: "error";
+        info: "info";
+        off: "off";
+        warn: "warn";
+    }>, z.ZodRecord<z.ZodString, z.ZodUnknown>], null>]>>>;
+    baseline: z.ZodOptional<z.ZodString>;
+    suppressions: z.ZodOptional<z.ZodObject<{
+        inline: z.ZodOptional<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const formatterConfigSchema: z.ZodObject<{
+    indentWidth: z.ZodOptional<z.ZodNumber>;
+    xmlDeclaration: z.ZodOptional<z.ZodEnum<{
+        always: "always";
+        never: "never";
+        preserve: "preserve";
+    }>>;
+    blankLineBetweenBehaviorTrees: z.ZodOptional<z.ZodBoolean>;
+    lineEnding: z.ZodOptional<z.ZodEnum<{
+        lf: "lf";
+        crlf: "crlf";
+        auto: "auto";
+    }>>;
+}, z.core.$strict>;
+declare const overrideConfigSchema: z.ZodObject<{
+    files: z.ZodArray<z.ZodString>;
+    linter: z.ZodOptional<z.ZodObject<{
+        rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+            error: "error";
+            info: "info";
+            off: "off";
+            warn: "warn";
+        }>, z.ZodTuple<[z.ZodEnum<{
+            error: "error";
+            info: "info";
+            off: "off";
+            warn: "warn";
+        }>, z.ZodRecord<z.ZodString, z.ZodUnknown>], null>]>>>;
+        suppressions: z.ZodOptional<z.ZodObject<{
+            inline: z.ZodOptional<z.ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    formatter: z.ZodOptional<z.ZodObject<{
+        indentWidth: z.ZodOptional<z.ZodNumber>;
+        xmlDeclaration: z.ZodOptional<z.ZodEnum<{
+            always: "always";
+            never: "never";
+            preserve: "preserve";
+        }>>;
+        blankLineBetweenBehaviorTrees: z.ZodOptional<z.ZodBoolean>;
+        lineEnding: z.ZodOptional<z.ZodEnum<{
+            lf: "lf";
+            crlf: "crlf";
+            auto: "auto";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const rawBtxmlConfigSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    strict: z.ZodOptional<z.ZodBoolean>;
+    files: z.ZodOptional<z.ZodObject<{
+        include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        ignore: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        useGitignore: z.ZodOptional<z.ZodBoolean>;
+        followSymlinks: z.ZodOptional<z.ZodBoolean>;
+        maxSize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    resolver: z.ZodOptional<z.ZodObject<{
+        entrypoints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        includes: z.ZodOptional<z.ZodObject<{
+            elements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                attribute: z.ZodString;
+                base: z.ZodOptional<z.ZodEnum<{
+                    file: "file";
+                    "project-root": "project-root";
+                }>>;
+            }, z.core.$strict>>>;
+            variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            allowOutsideRoot: z.ZodOptional<z.ZodBoolean>;
+            maxDepth: z.ZodOptional<z.ZodNumber>;
+            maxFiles: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        behaviorTreeIds: z.ZodOptional<z.ZodEnum<{
+            "workspace-unique": "workspace-unique";
+            "file-local-first": "file-local-first";
+            "allow-ambiguous": "allow-ambiguous";
+        }>>;
+    }, z.core.$strict>>;
+    models: z.ZodOptional<z.ZodObject<{
+        builtins: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            "btcpp-v4.6.2": "btcpp-v4.6.2";
+            "btcpp-v4.8.2": "btcpp-v4.8.2";
+            "btcpp-v4.9.0": "btcpp-v4.9.0";
+            "btcpp-v4": "btcpp-v4";
+        }>>>;
+        files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        augmentations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        definitions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        inline: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            kind: z.ZodEnum<{
+                Action: "Action";
+                Condition: "Condition";
+                Control: "Control";
+                Decorator: "Decorator";
+                SubTree: "SubTree";
+            }>;
+            ports: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                direction: z.ZodOptional<z.ZodEnum<{
+                    input: "input";
+                    output: "output";
+                    inout: "inout";
+                }>>;
+                type: z.ZodOptional<z.ZodString>;
+                required: z.ZodOptional<z.ZodBoolean>;
+                default: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    linter: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+            error: "error";
+            info: "info";
+            off: "off";
+            warn: "warn";
+        }>, z.ZodTuple<[z.ZodEnum<{
+            error: "error";
+            info: "info";
+            off: "off";
+            warn: "warn";
+        }>, z.ZodRecord<z.ZodString, z.ZodUnknown>], null>]>>>;
+        baseline: z.ZodOptional<z.ZodString>;
+        suppressions: z.ZodOptional<z.ZodObject<{
+            inline: z.ZodOptional<z.ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    formatter: z.ZodOptional<z.ZodObject<{
+        indentWidth: z.ZodOptional<z.ZodNumber>;
+        xmlDeclaration: z.ZodOptional<z.ZodEnum<{
+            always: "always";
+            never: "never";
+            preserve: "preserve";
+        }>>;
+        blankLineBetweenBehaviorTrees: z.ZodOptional<z.ZodBoolean>;
+        lineEnding: z.ZodOptional<z.ZodEnum<{
+            lf: "lf";
+            crlf: "crlf";
+            auto: "auto";
+        }>>;
+    }, z.core.$strict>>;
+    overrides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        files: z.ZodArray<z.ZodString>;
+        linter: z.ZodOptional<z.ZodObject<{
+            rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+                error: "error";
+                info: "info";
+                off: "off";
+                warn: "warn";
+            }>, z.ZodTuple<[z.ZodEnum<{
+                error: "error";
+                info: "info";
+                off: "off";
+                warn: "warn";
+            }>, z.ZodRecord<z.ZodString, z.ZodUnknown>], null>]>>>;
+            suppressions: z.ZodOptional<z.ZodObject<{
+                inline: z.ZodOptional<z.ZodEnum<{
+                    allow: "allow";
+                    deny: "deny";
+                }>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        formatter: z.ZodOptional<z.ZodObject<{
+            indentWidth: z.ZodOptional<z.ZodNumber>;
+            xmlDeclaration: z.ZodOptional<z.ZodEnum<{
+                always: "always";
+                never: "never";
+                preserve: "preserve";
+            }>>;
+            blankLineBetweenBehaviorTrees: z.ZodOptional<z.ZodBoolean>;
+            lineEnding: z.ZodOptional<z.ZodEnum<{
+                lf: "lf";
+                crlf: "crlf";
+                auto: "auto";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+type RawBtxmlConfigInput = z.input<typeof rawBtxmlConfigSchema>;
+type RawBtxmlConfig = z.output<typeof rawBtxmlConfigSchema>;
+type ConfigSeverity = z.output<typeof severitySchema>;
+type RuleConfig = z.output<typeof ruleConfigSchema>;
+type RawFilesConfig = z.output<typeof filesConfigSchema>;
+type RawResolverIncludesConfig = z.output<typeof resolverIncludesConfigSchema>;
+type RawResolverConfig = z.output<typeof resolverConfigSchema>;
+type RawModelsConfig = z.output<typeof modelsConfigSchema>;
+type RawLinterSuppressionsConfig = z.output<typeof linterSuppressionsConfigSchema>;
+type RawLinterConfig = z.output<typeof linterConfigSchema>;
+type RawFormatterConfig = z.output<typeof formatterConfigSchema>;
+type RawOverrideConfig = z.output<typeof overrideConfigSchema>;
+
+type ResolvedFilesConfig = {
+    include: string[];
+    ignore: string[];
+    useGitignore: boolean;
+    followSymlinks: boolean;
+    maxSize: number;
+};
+type ResolvedResolverIncludesConfig = {
+    elements: {
+        name: string;
+        attribute: string;
+        base: "file" | "project-root";
+    }[];
+    variables: Record<string, string>;
+    allowOutsideRoot: boolean;
+    maxDepth: number;
+    maxFiles: number;
+};
+type ResolvedResolverConfig = {
+    entrypoints: string[];
+    includes: ResolvedResolverIncludesConfig;
+    behaviorTreeIds: "workspace-unique" | "file-local-first" | "allow-ambiguous";
+};
+type ResolvedModelsConfig = {
+    builtins: string[];
+    files: string[];
+    augmentations: string[];
+    definitions: string[];
+    inline: Record<string, unknown>;
+};
+type ResolvedLinterSuppressionsConfig = {
+    inline: "allow" | "deny";
+};
+type ResolvedLinterConfig = {
+    enabled: boolean;
+    rules: Record<string, RuleConfig>;
+    baseline: string | undefined;
+    suppressions: ResolvedLinterSuppressionsConfig;
+};
+type ResolvedFormatterConfig = {
+    indentWidth: number;
+    xmlDeclaration: "always" | "never" | "preserve";
+    blankLineBetweenBehaviorTrees: boolean;
+    lineEnding: "lf" | "crlf" | "auto";
+};
+type PartialResolvedLinterSuppressionsConfig = {
+    inline?: ResolvedLinterSuppressionsConfig["inline"];
+};
+type PartialResolvedLinterConfig = {
+    enabled?: ResolvedLinterConfig["enabled"];
+    rules?: ResolvedLinterConfig["rules"];
+    baseline?: ResolvedLinterConfig["baseline"];
+    suppressions?: PartialResolvedLinterSuppressionsConfig;
+};
+type PartialResolvedFormatterConfig = {
+    indentWidth?: ResolvedFormatterConfig["indentWidth"];
+    xmlDeclaration?: ResolvedFormatterConfig["xmlDeclaration"];
+    blankLineBetweenBehaviorTrees?: ResolvedFormatterConfig["blankLineBetweenBehaviorTrees"];
+    lineEnding?: ResolvedFormatterConfig["lineEnding"];
+};
+type ResolvedOverrideConfig = {
+    files: string[];
+    linter?: PartialResolvedLinterConfig;
+    formatter?: PartialResolvedFormatterConfig;
+};
+type ResolvedBtxmlConfig = {
+    files: ResolvedFilesConfig;
+    resolver: ResolvedResolverConfig;
+    models: ResolvedModelsConfig;
+    linter: ResolvedLinterConfig;
+    formatter: ResolvedFormatterConfig;
+    overrides: ResolvedOverrideConfig[];
+};
+type EffectiveFileConfig = {
+    files: ResolvedFilesConfig;
+    resolver: ResolvedResolverConfig;
+    models: ResolvedModelsConfig;
+    linter: ResolvedLinterConfig;
+    formatter: ResolvedFormatterConfig;
+};
+type ConfigDiagnostic = {
+    code: string;
+    severity: "error" | "warning";
+    message: string;
+    path?: string;
+    help?: string;
+};
+type ConfigParseResult = {
+    ok: true;
+    value: RawBtxmlConfig;
+    diagnostics: ConfigDiagnostic[];
+} | {
+    ok: false;
+    diagnostics: ConfigDiagnostic[];
+};
+type ConfigNormalizeResult = {
+    ok: boolean;
+    config: ResolvedBtxmlConfig;
+    diagnostics: Diagnostic[];
+};
+
+export type { ConfigDiagnostic as C, EffectiveFileConfig as E, ResolvedBtxmlConfig as R, RawBtxmlConfig as a, RawBtxmlConfigInput as b, ResolvedOverrideConfig as c, ConfigNormalizeResult as d, ConfigParseResult as e, ConfigSeverity as f, RawFilesConfig as g, RawFormatterConfig as h, RawLinterConfig as i, RawLinterSuppressionsConfig as j, RawModelsConfig as k, RawOverrideConfig as l, RawResolverConfig as m, RawResolverIncludesConfig as n, ResolvedFilesConfig as o, ResolvedFormatterConfig as p, ResolvedLinterConfig as q, ResolvedLinterSuppressionsConfig as r, ResolvedModelsConfig as s, ResolvedResolverConfig as t, ResolvedResolverIncludesConfig as u, RuleConfig as v };

package/dist/types-CkOvIGPf.d.ts

@@ -0,0 +1,105 @@
+import { S as SourceRange } from './diagnostic-B5htzyJ9.js';
+import { T as TreeNodeKind$1, a as TreeNodeModelDef, N as NodeModelSource, P as PortDef } from './public-types-B2noBQY9.js';
+import { N as NodeUsageResolution, P as PortUsageResolution, S as SubTreeResolution, U as UsageResolverConfig, a as NodeUsagePolicy } from './types-SY4-jKCn.js';
+
+type TreeNodeKind = TreeNodeKind$1;
+type BuildSemanticDocumentViewOptions = {
+    readonly config?: UsageResolverConfig;
+    readonly policy?: Partial<NodeUsagePolicy>;
+};
+interface BlackboardReferenceView {
+    readonly raw: string;
+    readonly key: string;
+    readonly range: SourceRange;
+    readonly syntax: "braced" | "bare" | "invalid";
+}
+interface SemanticAttributeView {
+    readonly name: string;
+    readonly value: string;
+    readonly range: SourceRange;
+    readonly nameRange: SourceRange;
+    readonly valueRange: SourceRange | undefined;
+}
+type SemanticNodeModelResolution = {
+    readonly status: "resolved";
+    readonly model: TreeNodeModelDef;
+    readonly source: NodeModelSource | undefined;
+} | {
+    readonly status: "unresolved";
+    readonly nodeType: string;
+} | {
+    readonly status: "ambiguous";
+    readonly nodeType: string;
+    readonly candidates: readonly TreeNodeModelDef[];
+};
+type SemanticPortResolution = {
+    readonly status: "resolved";
+    readonly port: PortDef;
+} | {
+    readonly status: "allowed-arbitrary";
+    readonly name: string;
+} | {
+    readonly status: "undeclared";
+    readonly name: string;
+} | {
+    readonly status: "unknown-node-model";
+};
+interface SemanticPortBindingView {
+    readonly nodeId: string;
+    readonly portName: string;
+    readonly rawValue: string;
+    readonly direction: "input" | "output" | "inout" | "unknown";
+    readonly valueKind: "literal" | "blackboard-reference" | "substitution" | "empty" | "unknown";
+    readonly range: SourceRange;
+    readonly nameRange: SourceRange;
+    readonly valueRange: SourceRange | undefined;
+    readonly resolution: SemanticPortResolution;
+    readonly usage: PortUsageResolution;
+    readonly blackboardReferences: readonly BlackboardReferenceView[];
+}
+interface SemanticBehaviorTreeView {
+    readonly id: string | undefined;
+    readonly range: SourceRange;
+    readonly idRange: SourceRange | undefined;
+    readonly rootNodeId: string | undefined;
+    readonly nodeIds: readonly string[];
+}
+interface SemanticTreeNodeView {
+    readonly nodeId: string;
+    readonly path: readonly number[];
+    readonly instancePath: string;
+    readonly tagName: string;
+    readonly nodeType: string;
+    readonly name: string | undefined;
+    readonly idAttr: string | undefined;
+    readonly kind: TreeNodeKind | "unknown";
+    readonly range: SourceRange;
+    readonly fullRange: SourceRange | undefined;
+    readonly nameRange: SourceRange | undefined;
+    readonly parentNodeId: string | undefined;
+    readonly childNodeIds: readonly string[];
+    readonly behaviorTreeId: string | undefined;
+    readonly attributes: readonly SemanticAttributeView[];
+    readonly identityCandidates: readonly string[];
+    readonly model: SemanticNodeModelResolution;
+    readonly usage: NodeUsageResolution;
+    readonly portBindings: readonly SemanticPortBindingView[];
+}
+interface SemanticSubTreeCallView {
+    readonly nodeId: string;
+    readonly callId: string | undefined;
+    readonly range: SourceRange;
+    readonly target: SubTreeResolution;
+    readonly portBindings: readonly SemanticPortBindingView[];
+}
+interface SemanticDocumentView {
+    readonly uri: string;
+    readonly kind: "bt-xml" | "model-xml" | "unknown";
+    readonly mainTreeToExecute: string | undefined;
+    readonly mainTreeToExecuteRange: SourceRange | undefined;
+    readonly behaviorTrees: readonly SemanticBehaviorTreeView[];
+    readonly nodes: readonly SemanticTreeNodeView[];
+    readonly subtreeCalls: readonly SemanticSubTreeCallView[];
+}
+
+export type { BuildSemanticDocumentViewOptions as B, SemanticDocumentView as S, SemanticTreeNodeView as a, SemanticPortBindingView as b, SemanticSubTreeCallView as c };

package/dist/types-SY4-jKCn.d.ts

@@ -0,0 +1,112 @@
+import { a as BtXmlElement, b as BtXmlAttribute } from './ast-BbfR3S_b.js';
+import { B as BehaviorTreeDef, a as TreeNodeModelDef, P as PortDef } from './public-types-B2noBQY9.js';
+import { S as SemanticIndex, R as ResolveSubTreeInput } from './types-BaOc_AYN.js';
+
+type SubTreeResolution = {
+    readonly status: "resolved";
+    readonly kind: "behavior-tree";
+    readonly treeId: string;
+    readonly behaviorTree: BehaviorTreeDef;
+} | {
+    readonly status: "resolved";
+    readonly kind: "node-model";
+    readonly modelId: string;
+    readonly model: TreeNodeModelDef;
+} | {
+    readonly status: "ambiguous";
+    readonly candidates: readonly string[];
+    readonly behaviorTrees: readonly BehaviorTreeDef[];
+    readonly definitions: readonly TreeNodeModelDef[];
+} | {
+    readonly status: "unresolved";
+    readonly id: string | undefined;
+};
+declare function resolveSubTreeTarget(index: SemanticIndex, input: ResolveSubTreeInput): SubTreeResolution;
+
+type NodeTagForm = "root" | "behavior-tree" | "tree-nodes-model" | "model-definition" | "include" | "concrete-node" | "generic-node" | "subtree" | "unknown-xml";
+type UnknownSubTreePortMode = "allow" | "reject";
+type NodeUsagePolicy = {
+    readonly unknownSubTreePorts: UnknownSubTreePortMode;
+};
+type NodeUsageModelResolution = {
+    readonly status: "resolved";
+    readonly model: TreeNodeModelDef;
+} | {
+    readonly status: "ambiguous";
+    readonly nodeType: string;
+    readonly candidates: readonly TreeNodeModelDef[];
+} | {
+    readonly status: "unresolved";
+    readonly nodeType: string | undefined;
+} | {
+    readonly status: "not-a-node";
+};
+type PortUsageResolution = {
+    readonly status: "resolved";
+    readonly attribute: BtXmlAttribute;
+    readonly name: string;
+    readonly value: string;
+    readonly port: PortDef;
+} | {
+    readonly status: "undeclared";
+    readonly attribute: BtXmlAttribute;
+    readonly name: string;
+    readonly value: string;
+} | {
+    readonly status: "allowed-arbitrary";
+    readonly attribute: BtXmlAttribute;
+    readonly name: string;
+    readonly value: string;
+} | {
+    readonly status: "reserved-attribute";
+    readonly attribute: BtXmlAttribute;
+    readonly name: string;
+    readonly value: string;
+} | {
+    readonly status: "unknown-node-model";
+    readonly attribute: BtXmlAttribute;
+    readonly name: string;
+    readonly value: string;
+};
+type NodeUsageResolution = {
+    readonly element: BtXmlElement;
+    readonly tagName: string;
+    readonly tagForm: NodeTagForm;
+    readonly nodeType?: string;
+    readonly model: NodeUsageModelResolution;
+    readonly subtree?: {
+        readonly id?: string;
+        readonly target: SubTreeResolution;
+    };
+    readonly ports: readonly PortDef[];
+    readonly allowsArbitraryAttributes: boolean;
+    readonly portUsages: readonly PortUsageResolution[];
+};
+type UsageResolverBehaviorTreeIdPolicy = "workspace-unique" | "file-local-first" | "allow-ambiguous";
+type UsageResolverConfig = {
+    readonly resolver?: {
+        readonly behaviorTreeIds?: UsageResolverBehaviorTreeIdPolicy;
+    };
+};
+type ResolveNodeUsageInput = {
+    readonly element: BtXmlElement;
+    /**
+     * Root element of the parsed document that owns `element`.
+     *
+     * Required for distinguishing runtime node usages from TreeNodesModel
+     * declarations such as <Action>, <Condition>, <SubTree>, and port
+     * definition tags.
+     *
+     * Pass undefined only for intentionally detached elements.
+     */
+    readonly documentRoot: BtXmlElement | undefined;
+    readonly uri?: string;
+    readonly config?: UsageResolverConfig;
+    readonly policy?: Partial<NodeUsagePolicy>;
+    readonly isModelDefinition?: boolean;
+};
+type ResolvePortUsageInput = ResolveNodeUsageInput & {
+    readonly attributeName: string;
+};
+
+export { type NodeUsageResolution as N, type PortUsageResolution as P, type ResolveNodeUsageInput as R, type SubTreeResolution as S, type UsageResolverConfig as U, type NodeUsagePolicy as a, type ResolvePortUsageInput as b, resolveSubTreeTarget as r };