@elmeragroup/internal 0.1.1-canary.1

package/dist/index-C9vKRif1.d.mts

@@ -0,0 +1,815 @@
+/// <reference lib="esnext.disposable" />
+import { Context, Effect, Layer, Schema } from "effect";
+//#region ../api-extractor/dist/component-sources.d.ts
+declare const ComponentSourceRequestSchema: Schema.Struct<{
+  readonly exportName: Schema.String;
+  readonly memberName: Schema.optionalKey<Schema.String>;
+}>;
+type ComponentSourceRequest = typeof ComponentSourceRequestSchema.Type;
+declare const ComponentSourceDefaultSchema: Schema.Struct<{
+  readonly name: Schema.String;
+  readonly initializerText: Schema.String;
+}>;
+type ComponentSourceDefault = typeof ComponentSourceDefaultSchema.Type;
+declare const ComponentSourceUnresolvedReasonSchema: Schema.Literals<readonly ["export-not-found", "member-not-found", "no-implementation", "unsupported-wrapper", "unsupported-default-expression", "unresolved-export", "ambiguous-export", "cycle", "ambiguous-implementation"]>;
+type ComponentSourceUnresolvedReason = typeof ComponentSourceUnresolvedReasonSchema.Type;
+declare const ComponentSourceResolvedSchema: Schema.Struct<{
+  readonly status: Schema.Literal<"resolved">;
+  readonly filePath: Schema.String;
+  readonly defaults: Schema.$Array<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly initializerText: Schema.String;
+  }>>;
+}>;
+type ComponentSourceResolved = typeof ComponentSourceResolvedSchema.Type;
+/**
+ * The requested value is a dependency declaration that authored code forwards
+ * without implementing: `filePath` is the authored module whose re-export or
+ * alias forwards it, and `packageName` the dependency that owns the declaration.
+ */
+declare const ComponentSourceForwardedSchema: Schema.Struct<{
+  readonly status: Schema.Literal<"forwarded">;
+  readonly filePath: Schema.String;
+  readonly packageName: Schema.String;
+}>;
+type ComponentSourceForwarded = typeof ComponentSourceForwardedSchema.Type;
+declare const ComponentSourceUnresolvedSchema: Schema.Struct<{
+  readonly status: Schema.Literal<"unresolved">;
+  readonly reason: Schema.Literals<readonly ["export-not-found", "member-not-found", "no-implementation", "unsupported-wrapper", "unsupported-default-expression", "unresolved-export", "ambiguous-export", "cycle", "ambiguous-implementation"]>;
+}>;
+type ComponentSourceUnresolved = typeof ComponentSourceUnresolvedSchema.Type;
+declare const ComponentSourceResultSchema: Schema.Union<readonly [Schema.Struct<{
+  readonly status: Schema.Literal<"resolved">;
+  readonly filePath: Schema.String;
+  readonly defaults: Schema.$Array<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly initializerText: Schema.String;
+  }>>;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"forwarded">;
+  readonly filePath: Schema.String;
+  readonly packageName: Schema.String;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"unresolved">;
+  readonly reason: Schema.Literals<readonly ["export-not-found", "member-not-found", "no-implementation", "unsupported-wrapper", "unsupported-default-expression", "unresolved-export", "ambiguous-export", "cycle", "ambiguous-implementation"]>;
+}>]>;
+type ComponentSourceResult = typeof ComponentSourceResultSchema.Type;
+declare const ComponentSourceResultsSchema: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+  readonly status: Schema.Literal<"resolved">;
+  readonly filePath: Schema.String;
+  readonly defaults: Schema.$Array<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly initializerText: Schema.String;
+  }>>;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"forwarded">;
+  readonly filePath: Schema.String;
+  readonly packageName: Schema.String;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"unresolved">;
+  readonly reason: Schema.Literals<readonly ["export-not-found", "member-not-found", "no-implementation", "unsupported-wrapper", "unsupported-default-expression", "unresolved-export", "ambiguous-export", "cycle", "ambiguous-implementation"]>;
+}>]>>;
+type ComponentSourceResults = typeof ComponentSourceResultsSchema.Type;
+//#endregion
+//#region ../api-extractor/dist/errors.d.ts
+declare const ConfigError_base: Schema.Class<ConfigError, Schema.TaggedStruct<"ConfigError", {
+  readonly tsconfigPath: Schema.String;
+  readonly message: Schema.String;
+  readonly cause: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ConfigError extends ConfigError_base {}
+declare const BackendError_base: Schema.Class<BackendError, Schema.TaggedStruct<"BackendError", {
+  readonly message: Schema.String;
+  readonly cause: Schema.String;
+  readonly operation: Schema.optionalKey<Schema.String>;
+  readonly filePath: Schema.optionalKey<Schema.String>;
+  readonly symbolStack: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>, import("effect/Cause").YieldableError>;
+declare class BackendError extends BackendError_base {}
+declare const FileNotInProgramError_base: Schema.Class<FileNotInProgramError, Schema.TaggedStruct<"FileNotInProgramError", {
+  readonly filePath: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class FileNotInProgramError extends FileNotInProgramError_base {}
+declare const ExtractError_base: Schema.Class<ExtractError, Schema.TaggedStruct<"ExtractError", {
+  readonly filePath: Schema.String;
+  readonly symbolStack: Schema.$Array<Schema.String>;
+  readonly message: Schema.String;
+  readonly cause: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ExtractError extends ExtractError_base {}
+//#endregion
+//#region ../api-extractor/dist/model.d.ts
+/** Every intrinsic the model can name; the type, the schema, and the backend contract derive from it. */
+declare const intrinsicNames: readonly ["any", "bigint", "boolean", "never", "null", "number", "string", "symbol", "undefined", "unknown", "void"];
+type IntrinsicName = (typeof intrinsicNames)[number];
+type TypeName = typeof TypeNameSchema.Type;
+type TypeArgument = {
+  readonly type: SemanticType;
+  readonly equalToDefault: boolean;
+};
+declare const DocumentationTagSchema: Schema.Struct<{
+  readonly name: Schema.String;
+  readonly value: Schema.optionalKey<Schema.String>;
+}>;
+type DocumentationTag = typeof DocumentationTagSchema.Type;
+declare const DocumentationSchema: Schema.Struct<{
+  readonly description: Schema.optionalKey<Schema.String>;
+  readonly defaultValue: Schema.optionalKey<Schema.String>;
+  readonly visibility: Schema.optionalKey<Schema.Literals<readonly ["public", "private", "internal"]>>;
+  readonly tags: Schema.$Array<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly value: Schema.optionalKey<Schema.String>;
+  }>>;
+}>;
+type Documentation = typeof DocumentationSchema.Type;
+type IntrinsicNode = {
+  readonly kind: "intrinsic";
+  readonly typeName?: TypeName;
+  readonly intrinsic: IntrinsicName;
+};
+type ParameterNode = {
+  readonly type: SemanticType;
+  readonly name: string;
+  readonly documentation?: Documentation;
+  readonly optional: boolean;
+  readonly defaultValue?: string;
+};
+type TypeParameterNode = {
+  readonly name: string;
+  readonly constraint?: SemanticType;
+  readonly defaultValue?: SemanticType;
+  readonly kind: "typeParameter";
+};
+type CallSignatureNode = {
+  readonly parameters: readonly ParameterNode[];
+  readonly returnValueType: SemanticType;
+  readonly typeParameters?: readonly TypeParameterNode[];
+};
+type FunctionNode = {
+  readonly kind: "function";
+  readonly typeName?: TypeName;
+  readonly callSignatures: readonly CallSignatureNode[];
+};
+type PropertyNode = {
+  readonly name: string;
+  readonly type: SemanticType;
+  readonly documentation?: Documentation;
+  readonly optional: boolean;
+};
+type IndexSignatureNode = {
+  readonly keyName?: string;
+  readonly keyType: "string" | "number";
+  readonly valueType: SemanticType;
+};
+type ObjectNode = {
+  readonly kind: "object";
+  readonly typeName?: TypeName;
+  readonly properties: readonly PropertyNode[];
+  readonly documentation?: Documentation;
+  readonly indexSignature?: IndexSignatureNode;
+};
+type ComponentNode = {
+  readonly kind: "component";
+  readonly typeName?: TypeName;
+  readonly props: readonly PropertyNode[];
+};
+type ExternalTypeNode = {
+  readonly kind: "external";
+  readonly typeName: TypeName;
+};
+type UnionNode = {
+  readonly kind: "union";
+  readonly typeName?: TypeName;
+  readonly types: readonly SemanticType[];
+};
+type IntersectionNode = {
+  readonly kind: "intersection";
+  readonly typeName?: TypeName;
+  readonly types: readonly SemanticType[];
+  readonly properties: readonly PropertyNode[];
+};
+type TypeOperatorResolutionKind = "exact" | "baseConstraint" | "fallback";
+type TypeOperatorNode = {
+  readonly kind: "typeOperator";
+  readonly typeName?: TypeName;
+  readonly operator: "keyof";
+  readonly type: SemanticType;
+  /** The checker's key set for the operand; `type` keeps the authored expression. */
+  readonly resolvedType: SemanticType;
+  readonly resolutionKind: TypeOperatorResolutionKind;
+};
+type LiteralNode = {
+  readonly kind: "literal";
+  readonly typeName?: TypeName;
+  readonly value: string | number | boolean;
+  readonly documentation?: Documentation;
+};
+type EnumMember = {
+  readonly name: string;
+  readonly value: string | number;
+  readonly documentation?: Documentation;
+};
+type EnumNode = {
+  readonly kind: "enum";
+  readonly typeName: TypeName;
+  readonly members: readonly EnumMember[];
+  readonly documentation?: Documentation;
+};
+type ArrayNode = {
+  readonly kind: "array";
+  readonly typeName?: TypeName;
+  readonly elementType: SemanticType;
+  readonly isReadonly?: true;
+};
+type TupleNode = {
+  readonly kind: "tuple";
+  readonly typeName?: TypeName;
+  readonly types: readonly SemanticType[];
+  readonly isReadonly?: true;
+};
+type TypeQueryNode = {
+  readonly kind: "typeQuery";
+  readonly expressionName: string;
+};
+type ClassProperty = PropertyNode & {
+  readonly readonly: boolean;
+  readonly isStatic?: boolean;
+};
+type ConstructSignatureNode = {
+  readonly parameters: readonly ParameterNode[];
+  readonly documentation?: Documentation;
+};
+type ClassMethod = {
+  readonly name: string;
+  readonly documentation?: Documentation;
+  readonly isStatic?: boolean;
+  readonly callSignatures: readonly CallSignatureNode[];
+};
+type ClassNode = {
+  readonly kind: "class";
+  readonly typeName?: TypeName;
+  readonly constructSignatures: readonly ConstructSignatureNode[];
+  readonly properties: readonly ClassProperty[];
+  readonly methods: readonly ClassMethod[];
+  readonly typeParameters?: readonly TypeName[];
+};
+type SemanticType = ArrayNode | ClassNode | ComponentNode | EnumNode | ExternalTypeNode | FunctionNode | IntersectionNode | IntrinsicNode | LiteralNode | ObjectNode | TupleNode | TypeOperatorNode | TypeParameterNode | TypeQueryNode | UnionNode;
+declare const TypeNameSchema: Schema.Struct<{
+  readonly name: Schema.String;
+  readonly namespaces: Schema.optionalKey<Schema.$Array<Schema.String>>;
+  readonly typeArguments: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    readonly type: Schema.suspend<Schema.Codec<SemanticType, SemanticType, never, never>>;
+    readonly equalToDefault: Schema.Boolean;
+  }>>>;
+}>;
+declare const SemanticTypeSchema: Schema.Codec<SemanticType>;
+declare const ExportNodeSchema: Schema.Struct<{
+  readonly name: Schema.String;
+  readonly type: Schema.Codec<SemanticType, SemanticType, never, never>;
+  readonly documentation: Schema.optionalKey<Schema.Struct<{
+    readonly description: Schema.optionalKey<Schema.String>;
+    readonly defaultValue: Schema.optionalKey<Schema.String>;
+    readonly visibility: Schema.optionalKey<Schema.Literals<readonly ["public", "private", "internal"]>>;
+    readonly tags: Schema.$Array<Schema.Struct<{
+      readonly name: Schema.String;
+      readonly value: Schema.optionalKey<Schema.String>;
+    }>>;
+  }>>;
+  readonly reexportedFrom: Schema.optionalKey<Schema.String>;
+  readonly extendsTypes: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly resolvedName: Schema.optionalKey<Schema.String>;
+  }>>>;
+}>;
+type ExportNode = typeof ExportNodeSchema.Type;
+declare const ModuleNodeSchema: Schema.Struct<{
+  readonly name: Schema.String;
+  readonly exports: Schema.$Array<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly type: Schema.Codec<SemanticType, SemanticType, never, never>;
+    readonly documentation: Schema.optionalKey<Schema.Struct<{
+      readonly description: Schema.optionalKey<Schema.String>;
+      readonly defaultValue: Schema.optionalKey<Schema.String>;
+      readonly visibility: Schema.optionalKey<Schema.Literals<readonly ["public", "private", "internal"]>>;
+      readonly tags: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly value: Schema.optionalKey<Schema.String>;
+      }>>;
+    }>>;
+    readonly reexportedFrom: Schema.optionalKey<Schema.String>;
+    readonly extendsTypes: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+      readonly name: Schema.String;
+      readonly resolvedName: Schema.optionalKey<Schema.String>;
+    }>>>;
+  }>>;
+  readonly imports: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>;
+type ModuleNode = typeof ModuleNodeSchema.Type;
+declare const ExtractionResultSchema: Schema.Struct<{
+  readonly module: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly exports: Schema.$Array<Schema.Struct<{
+      readonly name: Schema.String;
+      readonly type: Schema.Codec<SemanticType, SemanticType, never, never>;
+      readonly documentation: Schema.optionalKey<Schema.Struct<{
+        readonly description: Schema.optionalKey<Schema.String>;
+        readonly defaultValue: Schema.optionalKey<Schema.String>;
+        readonly visibility: Schema.optionalKey<Schema.Literals<readonly ["public", "private", "internal"]>>;
+        readonly tags: Schema.$Array<Schema.Struct<{
+          readonly name: Schema.String;
+          readonly value: Schema.optionalKey<Schema.String>;
+        }>>;
+      }>>;
+      readonly reexportedFrom: Schema.optionalKey<Schema.String>;
+      readonly extendsTypes: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly resolvedName: Schema.optionalKey<Schema.String>;
+      }>>>;
+    }>>;
+    readonly imports: Schema.optionalKey<Schema.$Array<Schema.String>>;
+  }>;
+  readonly warnings: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly message: Schema.String;
+    readonly filePath: Schema.String;
+    readonly line: Schema.Number;
+    readonly column: Schema.Number;
+    readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+    readonly code: Schema.Literal<"unsupported-type-fallback">;
+    readonly typeFlags: Schema.$Array<Schema.Literals<readonly ["Any", "Unknown", "Undefined", "Null", "Void", "String", "Number", "BigInt", "Boolean", "ESSymbol", "StringLiteral", "NumberLiteral", "BigIntLiteral", "BooleanLiteral", "UniqueESSymbol", "EnumLiteral", "Enum", "NonPrimitive", "Never", "TypeParameter", "Object", "Index", "TemplateLiteral", "StringMapping", "Substitution", "IndexedAccess", "Conditional", "Union", "Intersection", "Other"]>>;
+    readonly typeText: Schema.String;
+    readonly sourceText: Schema.optionalKey<Schema.String>;
+  }>, Schema.Struct<{
+    readonly message: Schema.String;
+    readonly filePath: Schema.String;
+    readonly line: Schema.Number;
+    readonly column: Schema.Number;
+    readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+    readonly code: Schema.Literal<"missing-enum-declaration">;
+    readonly enumName: Schema.String;
+    readonly memberName: Schema.optionalKey<Schema.String>;
+  }>, Schema.Struct<{
+    readonly message: Schema.String;
+    readonly filePath: Schema.String;
+    readonly line: Schema.Number;
+    readonly column: Schema.Number;
+    readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+    readonly code: Schema.Literal<"missing-default-export-symbol">;
+    readonly sourceText: Schema.String;
+  }>, Schema.Struct<{
+    readonly message: Schema.String;
+    readonly filePath: Schema.String;
+    readonly line: Schema.Number;
+    readonly column: Schema.Number;
+    readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+    readonly code: Schema.Literal<"omitted-index-signature">;
+    readonly reason: Schema.Literals<readonly ["unrepresentable-key", "additional-signature"]>;
+    readonly keyTypes: Schema.$Array<Schema.Literals<readonly ["string", "number", "symbol", "other"]>>;
+  }>, Schema.Struct<{
+    readonly message: Schema.String;
+    readonly filePath: Schema.String;
+    readonly line: Schema.Number;
+    readonly column: Schema.Number;
+    readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+    readonly code: Schema.Literal<"unrepresented-construct-signatures">;
+    readonly structuralPath: Schema.$Array<Schema.String>;
+    readonly signatureCount: Schema.Natural;
+  }>, Schema.Struct<{
+    readonly message: Schema.String;
+    readonly filePath: Schema.String;
+    readonly line: Schema.Number;
+    readonly column: Schema.Number;
+    readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+    readonly code: Schema.Literal<"omitted-callable-members">;
+    readonly structuralPath: Schema.$Array<Schema.String>;
+    readonly memberNames: Schema.$Array<Schema.String>;
+  }>, Schema.Struct<{
+    readonly message: Schema.String;
+    readonly filePath: Schema.String;
+    readonly line: Schema.Number;
+    readonly column: Schema.Number;
+    readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+    readonly code: Schema.Literal<"unresolved-re-export">;
+    readonly reason: Schema.Literals<readonly ["missing-target", "cycle", "ambiguous"]>;
+    readonly name: Schema.String;
+  }>, Schema.Struct<{
+    readonly message: Schema.String;
+    readonly filePath: Schema.String;
+    readonly line: Schema.Number;
+    readonly column: Schema.Number;
+    readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+    readonly code: Schema.Literal<"uncertain-component-recognition">;
+    readonly reason: Schema.Literals<readonly ["mixed-component-union"]>;
+    readonly name: Schema.String;
+  }>]>>;
+  readonly provenance: Schema.$Array<Schema.Struct<{
+    readonly path: Schema.$Array<Schema.String>;
+    readonly declarations: Schema.$Array<Schema.Struct<{
+      readonly path: Schema.String;
+      readonly owner: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"project">;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"dependency">;
+        readonly packageName: Schema.String;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"external">;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"typescript">;
+        readonly library: Schema.Literals<readonly ["standard-library", "toolchain"]>;
+      }>]>>;
+    }>>;
+    readonly synthesized: Schema.Boolean;
+    readonly readonly: Schema.optionalKey<Schema.Boolean>;
+    readonly defaultInitializer: Schema.optionalKey<Schema.String>;
+    readonly reexportChain: Schema.optionalKey<Schema.$Array<Schema.String>>;
+  }>>;
+}>;
+//#endregion
+//#region ../api-extractor/dist/options.d.ts
+/** Data supplied before an object property is included in the semantic model. */
+type ShouldIncludeData = {
+  name: string;
+  depth: number;
+};
+/** Data supplied before an object's shape is expanded in the semantic model. */
+type ShouldResolveObjectData = {
+  /** Name of the object's type, or an empty string for an anonymous shape. */
+  name: string;
+  /** Number of properties the object would contribute to the output. */
+  propertyCount: number;
+  /** Depth of the type-resolution stack, counting every intermediate type. */
+  depth: number;
+  /** Number of property values traversed to reach this object. */
+  propertyDepth: number;
+};
+type ExtractorOptions = {
+  readonly shouldInclude?: (data: ShouldIncludeData) => boolean | undefined;
+  readonly shouldResolveObject?: (data: ShouldResolveObjectData) => boolean | undefined;
+  /**
+   * Expands no external types by default, every external type when `true`, or
+   * only dependency declarations owned by an exact package name in the list.
+   *
+   * The two non-`true` forms apply different quantifiers, on purpose: `false`
+   * summarizes a symbol as soon as ANY of its declarations is external
+   * (upstream's `isSymbolExternal`), while a package list expands a symbol only
+   * when EVERY declaration is project-owned or owned by a listed package, so a
+   * symbol merged from a listed and an unlisted dependency stays summarized.
+   */
+  readonly includeExternalTypes?: boolean | readonly string[];
+};
+declare const defaultExtractorOptions: Required<Pick<ExtractorOptions, "shouldResolveObject" | "includeExternalTypes">>;
+type ProjectFileSystemEntries = {
+  readonly files: readonly string[];
+  readonly directories: readonly string[];
+};
+type ProjectFileSystem = {
+  readonly directoryExists?: (directoryName: string) => boolean | undefined;
+  readonly fileExists?: (fileName: string) => boolean | undefined;
+  readonly getAccessibleEntries?: (directoryName: string) => ProjectFileSystemEntries | undefined;
+  readonly readFile?: (fileName: string) => string | null | undefined;
+  readonly realpath?: (path: string) => string | undefined;
+  readonly writeFile?: (path: string, content: string) => void;
+  readonly removeFile?: (path: string) => void;
+};
+type OpenProjectOptions = {
+  readonly tsconfigPath: string;
+  readonly cwd?: string;
+  readonly fileSystem?: ProjectFileSystem;
+};
+//#endregion
+//#region ../api-extractor/dist/extractor.d.ts
+type ExtractionResult = typeof ExtractionResultSchema.Type;
+type ExtractionErrors = BackendError | FileNotInProgramError | ExtractError;
+type ProjectExtractorService = {
+  readonly extractModule: (filePath: string, options?: ExtractorOptions) => Effect.Effect<ExtractionResult, ExtractionErrors>;
+  readonly inspectComponentSources: (filePath: string, requests: readonly ComponentSourceRequest[]) => Effect.Effect<readonly ComponentSourceResult[], ExtractionErrors>;
+};
+declare const ProjectExtractor_base: Context.ServiceClass<ProjectExtractor, "elmera/api-extractor/ProjectExtractor", ProjectExtractorService>;
+declare class ProjectExtractor extends ProjectExtractor_base {
+  static live(options: OpenProjectOptions): Layer.Layer<ProjectExtractor, ConfigError | BackendError>;
+}
+//#endregion
+//#region ../api-extractor/dist/provenance.d.ts
+/**
+ * Who owns one declaration file, as the backend classified it: the extracted
+ * project, a dependency package, an external file with no package owner, or
+ * TypeScript's own library or toolchain files.
+ */
+declare const DeclarationOwnerSchema: Schema.Union<readonly [Schema.Struct<{
+  readonly kind: Schema.Literal<"project">;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"dependency">;
+  readonly packageName: Schema.String;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"external">;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"typescript">;
+  readonly library: Schema.Literals<readonly ["standard-library", "toolchain"]>;
+}>]>;
+type DeclarationOwner = typeof DeclarationOwnerSchema.Type;
+/** One declaring source file of a model node, with its owner when the backend could classify it. */
+declare const ProvenanceDeclarationSchema: Schema.Struct<{
+  /** Repository-relative path of the declaring file. */
+  readonly path: Schema.String;
+  /**
+   * Who owns the file. Present whenever the backend reported a declaration
+   * handle for the path, so a consumer can ask "is this project-owned?" or
+   * "which package declares it?" without parsing the path.
+   */
+  readonly owner: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"project">;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"dependency">;
+    readonly packageName: Schema.String;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"external">;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"typescript">;
+    readonly library: Schema.Literals<readonly ["standard-library", "toolchain"]>;
+  }>]>>;
+}>;
+type ProvenanceDeclaration = typeof ProvenanceDeclarationSchema.Type;
+declare const ProvenanceEntrySchema: Schema.Struct<{
+  readonly path: Schema.$Array<Schema.String>;
+  /** The declaring files, sorted by path; empty for a compiler-synthesized node. */
+  readonly declarations: Schema.$Array<Schema.Struct<{
+    /** Repository-relative path of the declaring file. */
+    readonly path: Schema.String;
+    /**
+     * Who owns the file. Present whenever the backend reported a declaration
+     * handle for the path, so a consumer can ask "is this project-owned?" or
+     * "which package declares it?" without parsing the path.
+     */
+    readonly owner: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+      readonly kind: Schema.Literal<"project">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"dependency">;
+      readonly packageName: Schema.String;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"external">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"typescript">;
+      readonly library: Schema.Literals<readonly ["standard-library", "toolchain"]>;
+    }>]>>;
+  }>>;
+  readonly synthesized: Schema.Boolean;
+  /** Readonly declaration state kept out of the upstream semantic JSON model. */
+  readonly readonly: Schema.optionalKey<Schema.Boolean>;
+  readonly defaultInitializer: Schema.optionalKey<Schema.String>;
+  /**
+   * Repository-relative files of each intermediate re-export declaration that
+   * forwarded this export, outermost first. The original declaration site is
+   * carried by `declarations`; a directly declared export has no chain.
+   */
+  readonly reexportChain: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>;
+type ProvenanceEntry = typeof ProvenanceEntrySchema.Type;
+declare const ProvenanceSchema: Schema.$Array<Schema.Struct<{
+  readonly path: Schema.$Array<Schema.String>;
+  /** The declaring files, sorted by path; empty for a compiler-synthesized node. */
+  readonly declarations: Schema.$Array<Schema.Struct<{
+    /** Repository-relative path of the declaring file. */
+    readonly path: Schema.String;
+    /**
+     * Who owns the file. Present whenever the backend reported a declaration
+     * handle for the path, so a consumer can ask "is this project-owned?" or
+     * "which package declares it?" without parsing the path.
+     */
+    readonly owner: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+      readonly kind: Schema.Literal<"project">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"dependency">;
+      readonly packageName: Schema.String;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"external">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"typescript">;
+      readonly library: Schema.Literals<readonly ["standard-library", "toolchain"]>;
+    }>]>>;
+  }>>;
+  readonly synthesized: Schema.Boolean;
+  /** Readonly declaration state kept out of the upstream semantic JSON model. */
+  readonly readonly: Schema.optionalKey<Schema.Boolean>;
+  readonly defaultInitializer: Schema.optionalKey<Schema.String>;
+  /**
+   * Repository-relative files of each intermediate re-export declaration that
+   * forwarded this export, outermost first. The original declaration site is
+   * carried by `declarations`; a directly declared export has no chain.
+   */
+  readonly reexportChain: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>>;
+//#endregion
+//#region ../api-extractor/dist/warnings.d.ts
+declare const typeFlagNames: readonly ["Any", "Unknown", "Undefined", "Null", "Void", "String", "Number", "BigInt", "Boolean", "ESSymbol", "StringLiteral", "NumberLiteral", "BigIntLiteral", "BooleanLiteral", "UniqueESSymbol", "EnumLiteral", "Enum", "NonPrimitive", "Never", "TypeParameter", "Object", "Index", "TemplateLiteral", "StringMapping", "Substitution", "IndexedAccess", "Conditional", "Union", "Intersection", "Other"];
+type TypeFlagName = (typeof typeFlagNames)[number];
+/**
+ * Why an index signature the type declares is missing from the model.
+ *
+ * `unrepresentable-key` is a key domain the semantic model has no encoding for —
+ * a `symbol` key, or a template-literal pattern key. `additional-signature` is a
+ * key that *is* representable but lost the model's single index-signature slot,
+ * which is what happens to the legal `string` plus `number` pair.
+ */
+type OmittedIndexSignatureReason = "unrepresentable-key" | "additional-signature";
+/**
+ * Why a re-export produced no export: its alias chain dead-ends
+ * (`missing-target`) or returns to a namespace already being flattened
+ * (`cycle`). A third condition, `ambiguous`, is detected above this union by
+ * star-export collision analysis and reported with the same code.
+ */
+type UnresolvedReExportReason = "missing-target" | "cycle" | "ambiguous";
+/**
+ * Why an export that looks like a React component was left untransformed.
+ * `mixed-component-union` is a capitalized export whose union type holds some
+ * arms returning React node types and at least one arm that does not: the
+ * component heuristic cannot confirm the export describes one component, so
+ * the resolved union kind stands and this warning records the uncertainty
+ * instead of silently changing the semantic kind.
+ */
+type UncertainComponentRecognitionReason = "mixed-component-union";
+/** The extractor substituted `any` for a type shape it cannot model. */
+declare const UnsupportedTypeFallbackWarningSchema: Schema.Struct<{
+  readonly message: Schema.String;
+  readonly filePath: Schema.String;
+  readonly line: Schema.Number;
+  readonly column: Schema.Number;
+  readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+  readonly code: Schema.Literal<"unsupported-type-fallback">;
+  readonly typeFlags: Schema.$Array<Schema.Literals<readonly ["Any", "Unknown", "Undefined", "Null", "Void", "String", "Number", "BigInt", "Boolean", "ESSymbol", "StringLiteral", "NumberLiteral", "BigIntLiteral", "BooleanLiteral", "UniqueESSymbol", "EnumLiteral", "Enum", "NonPrimitive", "Never", "TypeParameter", "Object", "Index", "TemplateLiteral", "StringMapping", "Substitution", "IndexedAccess", "Conditional", "Union", "Intersection", "Other"]>>;
+  readonly typeText: Schema.String;
+  readonly sourceText: Schema.optionalKey<Schema.String>;
+}>;
+type UnsupportedTypeFallbackWarning = typeof UnsupportedTypeFallbackWarningSchema.Type;
+declare const MissingEnumDeclarationWarningSchema: Schema.Struct<{
+  readonly message: Schema.String;
+  readonly filePath: Schema.String;
+  readonly line: Schema.Number;
+  readonly column: Schema.Number;
+  readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+  readonly code: Schema.Literal<"missing-enum-declaration">;
+  readonly enumName: Schema.String;
+  readonly memberName: Schema.optionalKey<Schema.String>;
+}>;
+type MissingEnumDeclarationWarning = typeof MissingEnumDeclarationWarningSchema.Type;
+/**
+ * An `export default` expression the checker could not resolve to a symbol,
+ * so the export is skipped. Upstream emits the same condition.
+ */
+declare const MissingDefaultExportSymbolWarningSchema: Schema.Struct<{
+  readonly message: Schema.String;
+  readonly filePath: Schema.String;
+  readonly line: Schema.Number;
+  readonly column: Schema.Number;
+  readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+  readonly code: Schema.Literal<"missing-default-export-symbol">;
+  readonly sourceText: Schema.String;
+}>;
+type MissingDefaultExportSymbolWarning = typeof MissingDefaultExportSymbolWarningSchema.Type;
+declare const OmittedIndexSignatureWarningSchema: Schema.Struct<{
+  readonly message: Schema.String;
+  readonly filePath: Schema.String;
+  readonly line: Schema.Number;
+  readonly column: Schema.Number;
+  readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+  readonly code: Schema.Literal<"omitted-index-signature">;
+  readonly reason: Schema.Literals<readonly ["unrepresentable-key", "additional-signature"]>;
+  readonly keyTypes: Schema.$Array<Schema.Literals<readonly ["string", "number", "symbol", "other"]>>;
+}>;
+type OmittedIndexSignatureWarning = typeof OmittedIndexSignatureWarningSchema.Type;
+/**
+ * A construct signature the model cannot carry because its owner is not a
+ * class — an interface or object literal type that only declares `new (…)`.
+ * Upstream reports such shapes as bare objects; the warning records what was
+ * omitted and where in the semantic tree it would have lived.
+ */
+declare const UnrepresentedConstructSignaturesWarningSchema: Schema.Struct<{
+  readonly message: Schema.String;
+  readonly filePath: Schema.String;
+  readonly line: Schema.Number;
+  readonly column: Schema.Number;
+  readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+  readonly code: Schema.Literal<"unrepresented-construct-signatures">;
+  readonly structuralPath: Schema.$Array<Schema.String>;
+  readonly signatureCount: Schema.Natural;
+}>;
+type UnrepresentedConstructSignaturesWarning = typeof UnrepresentedConstructSignaturesWarningSchema.Type;
+/**
+ * Named members a callable shape carries besides its call signatures. A
+ * function node has no member list, so an interface that merges call
+ * signatures with properties keeps only the callable half; the warning names
+ * the members that did not survive.
+ */
+declare const OmittedCallableMembersWarningSchema: Schema.Struct<{
+  readonly message: Schema.String;
+  readonly filePath: Schema.String;
+  readonly line: Schema.Number;
+  readonly column: Schema.Number;
+  readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+  readonly code: Schema.Literal<"omitted-callable-members">;
+  readonly structuralPath: Schema.$Array<Schema.String>;
+  readonly memberNames: Schema.$Array<Schema.String>;
+}>;
+type OmittedCallableMembersWarning = typeof OmittedCallableMembersWarningSchema.Type;
+/**
+ * A re-export the module walk could not follow to an original declaration.
+ * The export is skipped; the warning names it, says why, and anchors the
+ * location at the re-exporting module.
+ */
+declare const UnresolvedReExportWarningSchema: Schema.Struct<{
+  readonly message: Schema.String;
+  readonly filePath: Schema.String;
+  readonly line: Schema.Number;
+  readonly column: Schema.Number;
+  readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+  readonly code: Schema.Literal<"unresolved-re-export">;
+  readonly reason: Schema.Literals<readonly ["missing-target", "cycle", "ambiguous"]>;
+  readonly name: Schema.String;
+}>;
+type UnresolvedReExportWarning = typeof UnresolvedReExportWarningSchema.Type;
+declare const UncertainComponentRecognitionWarningSchema: Schema.Struct<{
+  readonly message: Schema.String;
+  readonly filePath: Schema.String;
+  readonly line: Schema.Number;
+  readonly column: Schema.Number;
+  readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+  readonly code: Schema.Literal<"uncertain-component-recognition">;
+  readonly reason: Schema.Literals<readonly ["mixed-component-union"]>;
+  readonly name: Schema.String;
+}>;
+type UncertainComponentRecognitionWarning = typeof UncertainComponentRecognitionWarningSchema.Type;
+declare const ExtractWarningSchema: Schema.Union<readonly [Schema.Struct<{
+  readonly message: Schema.String;
+  readonly filePath: Schema.String;
+  readonly line: Schema.Number;
+  readonly column: Schema.Number;
+  readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+  readonly code: Schema.Literal<"unsupported-type-fallback">;
+  readonly typeFlags: Schema.$Array<Schema.Literals<readonly ["Any", "Unknown", "Undefined", "Null", "Void", "String", "Number", "BigInt", "Boolean", "ESSymbol", "StringLiteral", "NumberLiteral", "BigIntLiteral", "BooleanLiteral", "UniqueESSymbol", "EnumLiteral", "Enum", "NonPrimitive", "Never", "TypeParameter", "Object", "Index", "TemplateLiteral", "StringMapping", "Substitution", "IndexedAccess", "Conditional", "Union", "Intersection", "Other"]>>;
+  readonly typeText: Schema.String;
+  readonly sourceText: Schema.optionalKey<Schema.String>;
+}>, Schema.Struct<{
+  readonly message: Schema.String;
+  readonly filePath: Schema.String;
+  readonly line: Schema.Number;
+  readonly column: Schema.Number;
+  readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+  readonly code: Schema.Literal<"missing-enum-declaration">;
+  readonly enumName: Schema.String;
+  readonly memberName: Schema.optionalKey<Schema.String>;
+}>, Schema.Struct<{
+  readonly message: Schema.String;
+  readonly filePath: Schema.String;
+  readonly line: Schema.Number;
+  readonly column: Schema.Number;
+  readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+  readonly code: Schema.Literal<"missing-default-export-symbol">;
+  readonly sourceText: Schema.String;
+}>, Schema.Struct<{
+  readonly message: Schema.String;
+  readonly filePath: Schema.String;
+  readonly line: Schema.Number;
+  readonly column: Schema.Number;
+  readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+  readonly code: Schema.Literal<"omitted-index-signature">;
+  readonly reason: Schema.Literals<readonly ["unrepresentable-key", "additional-signature"]>;
+  readonly keyTypes: Schema.$Array<Schema.Literals<readonly ["string", "number", "symbol", "other"]>>;
+}>, Schema.Struct<{
+  readonly message: Schema.String;
+  readonly filePath: Schema.String;
+  readonly line: Schema.Number;
+  readonly column: Schema.Number;
+  readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+  readonly code: Schema.Literal<"unrepresented-construct-signatures">;
+  readonly structuralPath: Schema.$Array<Schema.String>;
+  readonly signatureCount: Schema.Natural;
+}>, Schema.Struct<{
+  readonly message: Schema.String;
+  readonly filePath: Schema.String;
+  readonly line: Schema.Number;
+  readonly column: Schema.Number;
+  readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+  readonly code: Schema.Literal<"omitted-callable-members">;
+  readonly structuralPath: Schema.$Array<Schema.String>;
+  readonly memberNames: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+  readonly message: Schema.String;
+  readonly filePath: Schema.String;
+  readonly line: Schema.Number;
+  readonly column: Schema.Number;
+  readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+  readonly code: Schema.Literal<"unresolved-re-export">;
+  readonly reason: Schema.Literals<readonly ["missing-target", "cycle", "ambiguous"]>;
+  readonly name: Schema.String;
+}>, Schema.Struct<{
+  readonly message: Schema.String;
+  readonly filePath: Schema.String;
+  readonly line: Schema.Number;
+  readonly column: Schema.Number;
+  readonly parsedSymbolStack: Schema.$Array<Schema.String>;
+  readonly code: Schema.Literal<"uncertain-component-recognition">;
+  readonly reason: Schema.Literals<readonly ["mixed-component-union"]>;
+  readonly name: Schema.String;
+}>]>;
+type ExtractWarning = typeof ExtractWarningSchema.Type;
+//#endregion
+export { ExtractionResultSchema as $, ExtractionResult as A, ComponentSourceRequestSchema as At, ArrayNode as B, ComponentSourceUnresolvedSchema as Bt, DeclarationOwner as C, ExtractError as Ct, ProvenanceEntry as D, ComponentSourceForwarded as Dt, ProvenanceDeclarationSchema as E, ComponentSourceDefaultSchema as Et, ProjectFileSystem as F, ComponentSourceResults as Ft, ComponentNode as G, ClassMethod as H, ProjectFileSystemEntries as I, ComponentSourceResultsSchema as It, DocumentationTag as J, ConstructSignatureNode as K, ShouldIncludeData as L, ComponentSourceUnresolved as Lt, ProjectExtractorService as M, ComponentSourceResolvedSchema as Mt, ExtractorOptions as N, ComponentSourceResult as Nt, ProvenanceEntrySchema as O, ComponentSourceForwardedSchema as Ot, OpenProjectOptions as P, ComponentSourceResultSchema as Pt, ExternalTypeNode as Q, ShouldResolveObjectData as R, ComponentSourceUnresolvedReason as Rt, UnsupportedTypeFallbackWarningSchema as S, ConfigError as St, ProvenanceDeclaration as T, ComponentSourceDefault as Tt, ClassNode as U, CallSignatureNode as V, ClassProperty as W, EnumNode as X, EnumMember as Y, ExportNode as Z, UnrepresentedConstructSignaturesWarningSchema as _, TypeOperatorResolutionKind as _t, MissingEnumDeclarationWarning as a, LiteralNode as at, UnresolvedReExportWarningSchema as b, UnionNode as bt, OmittedCallableMembersWarningSchema as c, ObjectNode as ct, OmittedIndexSignatureWarningSchema as d, SemanticType as dt, FunctionNode as et, TypeFlagName as f, SemanticTypeSchema as ft, UnrepresentedConstructSignaturesWarning as g, TypeOperatorNode as gt, UncertainComponentRecognitionWarningSchema as h, TypeName as ht, MissingDefaultExportSymbolWarningSchema as i, IntrinsicNode as it, ProjectExtractor as j, ComponentSourceResolved as jt, ProvenanceSchema as k, ComponentSourceRequest as kt, OmittedIndexSignatureReason as l, ParameterNode as lt, UncertainComponentRecognitionWarning as m, TypeArgument as mt, ExtractWarningSchema as n, IntersectionNode as nt, MissingEnumDeclarationWarningSchema as o, ModuleNode as ot, UncertainComponentRecognitionReason as p, TupleNode as pt, Documentation as q, MissingDefaultExportSymbolWarning as r, IntrinsicName as rt, OmittedCallableMembersWarning as s, ModuleNodeSchema as st, ExtractWarning as t, IndexSignatureNode as tt, OmittedIndexSignatureWarning as u, PropertyNode as ut, UnresolvedReExportReason as v, TypeParameterNode as vt, DeclarationOwnerSchema as w, FileNotInProgramError as wt, UnsupportedTypeFallbackWarning as x, BackendError as xt, UnresolvedReExportWarning as y, TypeQueryNode as yt, defaultExtractorOptions as z, ComponentSourceUnresolvedReasonSchema as zt };