@alint-js/languages 0.1.5

package/dist/index.d.mts

@@ -0,0 +1,1036 @@
+import { SourceFile, SourceTarget } from "@alint-js/core";
+//#region ../plugin/dist/index.d.mts
+//#region ../core/dist/types-DM4idR4w.d.mts
+//#region src/core/source/types.d.ts
+interface BaseSourceFile {
+  contentHash: string;
+  language: string;
+  path: string;
+}
+type ClassTarget = PlannedSourceTargetOfKind<'class'>;
+type FileTarget = PlannedSourceTargetOfKind<'file'>;
+type FunctionTarget = PlannedSourceTargetOfKind<'function'>;
+interface LanguageContext {
+  cwd: string;
+  languageOptions: Record<string, unknown>;
+  src: SourceRuntime;
+}
+interface LineRange {
+  endLine: number;
+  startLine: number;
+}
+interface PlannedSourceTarget {
+  file: BaseSourceFile;
+  identity: string;
+  kind: SourceTargetKind;
+  language: string;
+  loc?: SourceLocation;
+  metadata?: SourceTargetMetadata;
+  name?: string;
+  origin?: SourceTargetOrigin;
+  range?: SourceRange;
+}
+type PlannedSourceTargetOfKind<Kind extends SourceTargetKind> = Omit<PlannedSourceTarget, 'kind'> & {
+  kind: Kind;
+};
+interface ProcessedSource {
+  identity: string;
+  language?: string;
+  origin?: ProcessedSourceOrigin;
+  path: string;
+  text: string;
+}
+interface ProcessedSourceOrigin {
+  physicalPath: string;
+  range?: SourceRange;
+  virtualPath?: string;
+}
+interface ProcessorContext {
+  cwd: string;
+  options: Record<string, unknown>;
+  src: SourceRuntime;
+}
+interface ProcessorPostprocessContext extends ProcessorContext {
+  file: SourceFile$1;
+  processedSources: ProcessedSource[];
+}
+interface SourceExtractOptions {
+  /**
+   * Overrides the file's configured `language:` pin.
+   *
+   * For a caller walking a mixed tree, where the file's own config cannot know what each file is.
+   */
+  language?: string;
+}
+interface SourceFile$1 extends BaseSourceFile {
+  lines: string[];
+  text: string;
+}
+interface SourceLocation {
+  end: SourcePosition;
+  start: SourcePosition;
+}
+interface SourceMetadataObject {
+  readonly [key: string]: SourceMetadataValue;
+}
+type SourceMetadataValue = boolean | null | number | readonly SourceMetadataValue[] | SourceMetadataObject | SourceRange | string;
+interface SourcePosition {
+  column: number;
+  line: number;
+}
+interface SourceRange {
+  end: number;
+  start: number;
+}
+interface SourceRuntime {
+  /**
+   * Targets for any file, linted or not.
+   *
+   * Resolves the file's own config the way linting does, resolves its language from that config,
+   * and runs that language's extract. A rule handed `ProjectTarget.files`, or an index builder
+   * sweeping files outside the lint set, has no other way to parse them.
+   *
+   * An ignored file extracts to `[]` rather than throwing: sweeping broadly and skipping what the
+   * config excluded is the normal case, not an error.
+   *
+   * Only wired inside a run. A runtime built by `createSourceRuntime()` with no extractor throws,
+   * because there is no config to resolve the file against.
+   */
+  extract: (filePath: string, options?: SourceExtractOptions) => Promise<SourceTarget$1[]>;
+  getText: (file: SourceFile$1) => string;
+  readFile: (file: BaseSourceFile | string) => Promise<SourceFile$1>;
+  sliceLines: (file: SourceFile$1, range: LineRange) => SourceText;
+  sliceRange: (file: SourceFile$1, range: SourceRange) => SourceText;
+}
+interface SourceTarget$1 {
+  file: SourceFile$1;
+  identity: string;
+  kind: SourceTargetKind;
+  language: string;
+  loc?: SourceLocation;
+  metadata?: SourceTargetMetadata;
+  name?: string;
+  origin?: SourceTargetOrigin;
+  range?: SourceRange;
+  text: string;
+}
+type SourceTargetKind = 'class' | 'file' | 'fragment' | 'function' | 'symbol' | (string & {});
+type SourceTargetMetadata = Readonly<Record<string, SourceMetadataValue>>;
+interface SourceTargetOrigin {
+  physicalPath: string;
+  range?: SourceRange;
+  virtualPath?: string;
+}
+interface SourceText {
+  filePath: string;
+  loc: SourceLocation;
+  text: string;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/valibot@1.4.2_typescript@6.0.3/node_modules/valibot/dist/index.d.mts
+//#endregion
+//#region src/types/metadata.d.ts
+/**
+ * Base metadata interface.
+ */
+interface BaseMetadata<TInput$1> {
+  /**
+   * The object kind.
+   */
+  readonly kind: "metadata";
+  /**
+   * The metadata type.
+   */
+  readonly type: string;
+  /**
+   * The metadata reference.
+   */
+  readonly reference: (...args: any[]) => BaseMetadata<any>;
+  /**
+   * The input, output and issue type.
+   *
+   * @internal
+   */
+  readonly "~types"?: {
+    readonly input: TInput$1;
+    readonly output: TInput$1;
+    readonly issue: never;
+  } | undefined;
+}
+//#endregion
+//#region src/types/dataset.d.ts
+/**
+ * Unknown dataset interface.
+ */
+interface UnknownDataset {
+  /**
+   * Whether is's typed.
+   */
+  typed?: false;
+  /**
+   * The dataset value.
+   */
+  value: unknown;
+  /**
+   * The dataset issues.
+   */
+  issues?: undefined;
+}
+/**
+ * Success dataset interface.
+ */
+interface SuccessDataset<TValue$1> {
+  /**
+   * Whether is's typed.
+   */
+  typed: true;
+  /**
+   * The dataset value.
+   */
+  value: TValue$1;
+  /**
+   * The dataset issues.
+   */
+  issues?: undefined;
+}
+/**
+ * Partial dataset interface.
+ */
+interface PartialDataset<TValue$1, TIssue extends BaseIssue<unknown>> {
+  /**
+   * Whether is's typed.
+   */
+  typed: true;
+  /**
+   * The dataset value.
+   */
+  value: TValue$1;
+  /**
+   * The dataset issues.
+   */
+  issues: [TIssue, ...TIssue[]];
+}
+/**
+ * Failure dataset interface.
+ */
+interface FailureDataset<TIssue extends BaseIssue<unknown>> {
+  /**
+   * Whether is's typed.
+   */
+  typed: false;
+  /**
+   * The dataset value.
+   */
+  value: unknown;
+  /**
+   * The dataset issues.
+   */
+  issues: [TIssue, ...TIssue[]];
+}
+/**
+ * Output dataset type.
+ */
+type OutputDataset<TValue$1, TIssue extends BaseIssue<unknown>> = SuccessDataset<TValue$1> | PartialDataset<TValue$1, TIssue> | FailureDataset<TIssue>;
+//#endregion
+//#region src/types/standard.d.ts
+/**
+ * The Standard Schema properties interface.
+ */
+interface StandardProps<TInput$1, TOutput$1> {
+  /**
+   * The version number of the standard.
+   */
+  readonly version: 1;
+  /**
+   * The vendor name of the schema library.
+   */
+  readonly vendor: "valibot";
+  /**
+   * Validates unknown input values.
+   */
+  readonly validate: (value: unknown) => StandardResult<TOutput$1> | Promise<StandardResult<TOutput$1>>;
+  /**
+   * Inferred types associated with the schema.
+   */
+  readonly types?: StandardTypes<TInput$1, TOutput$1> | undefined;
+}
+/**
+ * The result interface of the validate function.
+ */
+type StandardResult<TOutput$1> = StandardSuccessResult<TOutput$1> | StandardFailureResult;
+/**
+ * The result interface if validation succeeds.
+ */
+interface StandardSuccessResult<TOutput$1> {
+  /**
+   * The typed output value.
+   */
+  readonly value: TOutput$1;
+  /**
+   * The non-existent issues.
+   */
+  readonly issues?: undefined;
+}
+/**
+ * The result interface if validation fails.
+ */
+interface StandardFailureResult {
+  /**
+   * The issues of failed validation.
+   */
+  readonly issues: readonly StandardIssue[];
+}
+/**
+ * The issue interface of the failure output.
+ */
+interface StandardIssue {
+  /**
+   * The error message of the issue.
+   */
+  readonly message: string;
+  /**
+   * The path of the issue, if any.
+   */
+  readonly path?: readonly (PropertyKey | StandardPathItem)[] | undefined;
+}
+/**
+ * The path item interface of the issue.
+ */
+interface StandardPathItem {
+  /**
+   * The key of the path item.
+   */
+  readonly key: PropertyKey;
+}
+/**
+ * The Standard Schema types interface.
+ */
+interface StandardTypes<TInput$1, TOutput$1> {
+  /**
+   * The input type of the schema.
+   */
+  readonly input: TInput$1;
+  /**
+   * The output type of the schema.
+   */
+  readonly output: TOutput$1;
+}
+//#endregion
+//#region src/types/schema.d.ts
+/**
+ * Base schema interface.
+ */
+interface BaseSchema<TInput$1, TOutput$1, TIssue extends BaseIssue<unknown>> {
+  /**
+   * The object kind.
+   */
+  readonly kind: "schema";
+  /**
+   * The schema type.
+   */
+  readonly type: string;
+  /**
+   * The schema reference.
+   */
+  readonly reference: (...args: any[]) => BaseSchema<unknown, unknown, BaseIssue<unknown>>;
+  /**
+   * The expected property.
+   */
+  readonly expects: string;
+  /**
+   * Whether it's async.
+   */
+  readonly async: false;
+  /**
+   * The Standard Schema properties.
+   *
+   * @internal
+   */
+  readonly "~standard": StandardProps<TInput$1, TOutput$1>;
+  /**
+   * Parses unknown input values.
+   *
+   * @param dataset The input dataset.
+   * @param config The configuration.
+   *
+   * @returns The output dataset.
+   *
+   * @internal
+   */
+  readonly "~run": (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput$1, TIssue>;
+  /**
+   * The input, output and issue type.
+   *
+   * @internal
+   */
+  readonly "~types"?: {
+    readonly input: TInput$1;
+    readonly output: TOutput$1;
+    readonly issue: TIssue;
+  } | undefined;
+}
+/**
+ * Base schema async interface.
+ */
+interface BaseSchemaAsync<TInput$1, TOutput$1, TIssue extends BaseIssue<unknown>> extends Omit<BaseSchema<TInput$1, TOutput$1, TIssue>, "reference" | "async" | "~run"> {
+  /**
+   * The schema reference.
+   */
+  readonly reference: (...args: any[]) => BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>;
+  /**
+   * Whether it's async.
+   */
+  readonly async: true;
+  /**
+   * Parses unknown input values.
+   *
+   * @param dataset The input dataset.
+   * @param config The configuration.
+   *
+   * @returns The output dataset.
+   *
+   * @internal
+   */
+  readonly "~run": (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput$1, TIssue>>;
+}
+/**
+ * Generic schema type.
+ */
+type GenericSchema<TInput$1 = unknown, TOutput$1 = TInput$1, TIssue extends BaseIssue<unknown> = BaseIssue<unknown>> = BaseSchema<TInput$1, TOutput$1, TIssue>;
+//#endregion
+//#region src/types/transformation.d.ts
+/**
+ * Base transformation interface.
+ */
+interface BaseTransformation<TInput$1, TOutput$1, TIssue extends BaseIssue<unknown>> {
+  /**
+   * The object kind.
+   */
+  readonly kind: "transformation";
+  /**
+   * The transformation type.
+   */
+  readonly type: string;
+  /**
+   * The transformation reference.
+   */
+  readonly reference: (...args: any[]) => BaseTransformation<any, any, BaseIssue<unknown>>;
+  /**
+   * Whether it's async.
+   */
+  readonly async: false;
+  /**
+   * Transforms known input values.
+   *
+   * @param dataset The input dataset.
+   * @param config The configuration.
+   *
+   * @returns The output dataset.
+   *
+   * @internal
+   */
+  readonly "~run": (dataset: SuccessDataset<TInput$1>, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput$1, BaseIssue<unknown> | TIssue>;
+  /**
+   * The input, output and issue type.
+   *
+   * @internal
+   */
+  readonly "~types"?: {
+    readonly input: TInput$1;
+    readonly output: TOutput$1;
+    readonly issue: TIssue;
+  } | undefined;
+}
+/**
+ * Base transformation async interface.
+ */
+interface BaseTransformationAsync<TInput$1, TOutput$1, TIssue extends BaseIssue<unknown>> extends Omit<BaseTransformation<TInput$1, TOutput$1, TIssue>, "reference" | "async" | "~run"> {
+  /**
+   * The transformation reference.
+   */
+  readonly reference: (...args: any[]) => BaseTransformation<any, any, BaseIssue<unknown>> | BaseTransformationAsync<any, any, BaseIssue<unknown>>;
+  /**
+   * Whether it's async.
+   */
+  readonly async: true;
+  /**
+   * Transforms known input values.
+   *
+   * @param dataset The input dataset.
+   * @param config The configuration.
+   *
+   * @returns The output dataset.
+   *
+   * @internal
+   */
+  readonly "~run": (dataset: SuccessDataset<TInput$1>, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput$1, BaseIssue<unknown> | TIssue>>;
+}
+//#endregion
+//#region src/types/validation.d.ts
+/**
+ * Base validation interface.
+ */
+interface BaseValidation<TInput$1, TOutput$1, TIssue extends BaseIssue<unknown>> {
+  /**
+   * The object kind.
+   */
+  readonly kind: "validation";
+  /**
+   * The validation type.
+   */
+  readonly type: string;
+  /**
+   * The validation reference.
+   */
+  readonly reference: (...args: any[]) => BaseValidation<any, any, BaseIssue<unknown>>;
+  /**
+   * The expected property.
+   */
+  readonly expects: string | null;
+  /**
+   * Whether it's async.
+   */
+  readonly async: false;
+  /**
+   * Validates known input values.
+   *
+   * @param dataset The input dataset.
+   * @param config The configuration.
+   *
+   * @returns The output dataset.
+   *
+   * @internal
+   */
+  readonly "~run": (dataset: OutputDataset<TInput$1, BaseIssue<unknown>>, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput$1, BaseIssue<unknown> | TIssue>;
+  /**
+   * The input, output and issue type.
+   *
+   * @internal
+   */
+  readonly "~types"?: {
+    readonly input: TInput$1;
+    readonly output: TOutput$1;
+    readonly issue: TIssue;
+  } | undefined;
+}
+/**
+ * Base validation async interface.
+ */
+interface BaseValidationAsync<TInput$1, TOutput$1, TIssue extends BaseIssue<unknown>> extends Omit<BaseValidation<TInput$1, TOutput$1, TIssue>, "reference" | "async" | "~run"> {
+  /**
+   * The validation reference.
+   */
+  readonly reference: (...args: any[]) => BaseValidation<any, any, BaseIssue<unknown>> | BaseValidationAsync<any, any, BaseIssue<unknown>>;
+  /**
+   * Whether it's async.
+   */
+  readonly async: true;
+  /**
+   * Validates known input values.
+   *
+   * @param dataset The input dataset.
+   * @param config The configuration.
+   *
+   * @returns The output dataset.
+   *
+   * @internal
+   */
+  readonly "~run": (dataset: OutputDataset<TInput$1, BaseIssue<unknown>>, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput$1, BaseIssue<unknown> | TIssue>>;
+}
+/**
+ * Infer output type.
+ */
+type InferOutput<TItem$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | BaseValidation<any, unknown, BaseIssue<unknown>> | BaseValidationAsync<any, unknown, BaseIssue<unknown>> | BaseTransformation<any, unknown, BaseIssue<unknown>> | BaseTransformationAsync<any, unknown, BaseIssue<unknown>> | BaseMetadata<any>> = NonNullable<TItem$1["~types"]>["output"];
+/**
+ * Constructs a type that is maybe readonly.
+ */
+type MaybeReadonly<TValue$1> = TValue$1 | Readonly<TValue$1>;
+//#endregion
+//#region src/types/other.d.ts
+/**
+ * Error message type.
+ */
+type ErrorMessage<TIssue extends BaseIssue<unknown>> = ((issue: TIssue) => string) | string;
+//#endregion
+//#region src/types/issue.d.ts
+/**
+ * Array path item interface.
+ */
+interface ArrayPathItem {
+  /**
+   * The path item type.
+   */
+  readonly type: "array";
+  /**
+   * The path item origin.
+   */
+  readonly origin: "value";
+  /**
+   * The path item input.
+   */
+  readonly input: MaybeReadonly<unknown[]>;
+  /**
+   * The path item key.
+   */
+  readonly key: number;
+  /**
+   * The path item value.
+   */
+  readonly value: unknown;
+}
+/**
+ * Map path item interface.
+ */
+interface MapPathItem {
+  /**
+   * The path item type.
+   */
+  readonly type: "map";
+  /**
+   * The path item origin.
+   */
+  readonly origin: "key" | "value";
+  /**
+   * The path item input.
+   */
+  readonly input: Map<unknown, unknown>;
+  /**
+   * The path item key.
+   */
+  readonly key: unknown;
+  /**
+   * The path item value.
+   */
+  readonly value: unknown;
+}
+/**
+ * Object path item interface.
+ */
+interface ObjectPathItem {
+  /**
+   * The path item type.
+   */
+  readonly type: "object";
+  /**
+   * The path item origin.
+   */
+  readonly origin: "key" | "value";
+  /**
+   * The path item input.
+   */
+  readonly input: Record<string, unknown>;
+  /**
+   * The path item key.
+   */
+  readonly key: string;
+  /**
+   * The path item value.
+   */
+  readonly value: unknown;
+}
+/**
+ * Set path item interface.
+ */
+interface SetPathItem {
+  /**
+   * The path item type.
+   */
+  readonly type: "set";
+  /**
+   * The path item origin.
+   */
+  readonly origin: "value";
+  /**
+   * The path item input.
+   */
+  readonly input: Set<unknown>;
+  /**
+   * The path item key.
+   */
+  readonly key: null;
+  /**
+   * The path item key.
+   */
+  readonly value: unknown;
+}
+/**
+ * Unknown path item interface.
+ */
+interface UnknownPathItem {
+  /**
+   * The path item type.
+   */
+  readonly type: "unknown";
+  /**
+   * The path item origin.
+   */
+  readonly origin: "key" | "value";
+  /**
+   * The path item input.
+   */
+  readonly input: unknown;
+  /**
+   * The path item key.
+   */
+  readonly key: unknown;
+  /**
+   * The path item value.
+   */
+  readonly value: unknown;
+}
+/**
+ * Issue path item type.
+ */
+type IssuePathItem = ArrayPathItem | MapPathItem | ObjectPathItem | SetPathItem | UnknownPathItem;
+/**
+ * Base issue interface.
+ */
+interface BaseIssue<TInput$1> extends Config<BaseIssue<TInput$1>> {
+  /**
+   * The issue kind.
+   */
+  readonly kind: "schema" | "validation" | "transformation";
+  /**
+   * The issue type.
+   */
+  readonly type: string;
+  /**
+   * The raw input data.
+   */
+  readonly input: TInput$1;
+  /**
+   * The expected property.
+   */
+  readonly expected: string | null;
+  /**
+   * The received property.
+   */
+  readonly received: string;
+  /**
+   * The error message.
+   */
+  readonly message: string;
+  /**
+   * The input requirement.
+   */
+  readonly requirement?: unknown | undefined;
+  /**
+   * The issue path.
+   */
+  readonly path?: [IssuePathItem, ...IssuePathItem[]] | undefined;
+  /**
+   * The sub issues.
+   */
+  readonly issues?: [BaseIssue<TInput$1>, ...BaseIssue<TInput$1>[]] | undefined;
+}
+//#endregion
+//#region src/types/config.d.ts
+/**
+ * Config interface.
+ */
+interface Config<TIssue extends BaseIssue<unknown>> {
+  /**
+   * The selected language.
+   */
+  readonly lang?: string | undefined;
+  /**
+   * The error message.
+   */
+  readonly message?: ErrorMessage<TIssue> | undefined;
+  /**
+   * Whether it should be aborted early.
+   */
+  readonly abortEarly?: boolean | undefined;
+  /**
+   * Whether a pipe should be aborted early.
+   */
+  readonly abortPipeEarly?: boolean | undefined;
+}
+//#endregion
+//#region ../core/dist/types-deBCDA4_.d.mts
+//#region src/config/types.d.ts
+type ModelSize = 'large' | 'medium' | 'small';
+interface RunnerCacheConfig {
+  enabled?: boolean;
+  location?: string;
+}
+interface RunnerConfig {
+  /** Retries after the initial attempt for replay-safe agent failures. @default 2 */
+  agentRetries?: number;
+  cache?: boolean | RunnerCacheConfig;
+  ruleConcurrency?: number;
+  stats?: boolean | RunnerStatsConfig;
+  timeoutMs?: number;
+}
+interface RunnerStatsConfig {
+  enabled?: boolean;
+  location?: string;
+  retentionMonths?: number;
+}
+//#endregion
+//#region src/models/types.d.ts
+interface ModelRequirement {
+  capabilities?: string[];
+  minContextWindow?: number;
+  params?: Record<string, unknown>;
+  size?: ModelSize;
+}
+interface ResolvedModel {
+  aliases: string[];
+  capabilities: string[];
+  contextWindow?: number;
+  id: string;
+  name: string;
+  params: Record<string, unknown>;
+  provider: ResolvedProvider;
+  size?: ModelSize;
+}
+interface ResolvedProvider {
+  endpoint: string;
+  headers: Record<string, string>;
+  id: string;
+  type: 'openai-compatible';
+}
+//#endregion
+//#region src/agent/types.d.ts
+type AgentAdapter = (request: AgentRequest) => Promise<AgentResult>;
+interface AgentRequest {
+  instructions: string;
+  model: ResolvedModel;
+  prompt: string;
+  signal?: AbortSignal;
+  tools: AgentTool[];
+}
+interface AgentResult {
+  answer: string;
+  usage?: AgentUsage;
+}
+/** Agent-agnostic tool definition. Each adapter translates it to its framework's tool format. */
+interface AgentTool {
+  description: string;
+  execute: (input: unknown) => Promise<unknown> | unknown;
+  name: string;
+  parameters: Record<string, unknown>;
+}
+interface AgentUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+}
+type AlintConfigExtends = AlintConfigInput | string;
+type AlintConfigInput = AlintConfigItem | readonly AlintConfigInput[];
+interface AlintConfigItem {
+  agent?: AgentAdapter;
+  basePath?: string;
+  directories?: readonly (readonly string[] | string)[];
+  extends?: readonly AlintConfigExtends[];
+  files?: readonly (readonly string[] | string)[];
+  ignore?: IgnoreConfig;
+  ignores?: readonly string[];
+  language?: string;
+  languageOptions?: Record<string, unknown>;
+  linterOptions?: AlintLinterOptions;
+  name?: string;
+  plugins?: Record<string, PluginDefinition>;
+  processor?: ProcessorDefinition | string;
+  rules?: Record<string, RuleConfigEntry>;
+  runner?: RunnerConfig;
+  settings?: Record<string, unknown>;
+}
+interface AlintLinterOptions {
+  noInlineConfig?: boolean;
+  /**
+   * How the run reports files it lints that no language claimed, so they were handled as plain
+   * text. Defaults to `'warn'`. An explicit `language: 'plaintext'` pin means plain text was the
+   * intent, so pinned files are never reported.
+   */
+  reportUnregisteredLanguages?: RuleSeverity;
+  reportUnusedDisableDirectives?: RuleSeverity;
+}
+type Awaitable<T> = Promise<T> | T;
+interface DiagnosticDescriptor {
+  evidence?: unknown;
+  filePath?: string;
+  loc?: DiagnosticLocation;
+  message: string;
+}
+interface DiagnosticLocation {
+  end?: {
+    column: number;
+    line: number;
+  };
+  start: {
+    column: number;
+    line: number;
+  };
+}
+interface DirectoryTarget {
+  kind: 'directory';
+  path: string;
+}
+interface IgnoreConfig {
+  gitignore?: boolean;
+}
+interface LanguageDefinition {
+  extensions?: readonly string[];
+  extract: (file: SourceFile$1, context: LanguageContext) => Awaitable<SourceTarget$1[]>;
+  /**
+   * The language's id: what a config pins through `language:`, what a rule's `languages` lists, and
+   * what every target it extracts reports. The registry is keyed by it, so two packs cannot claim
+   * the same one.
+   *
+   * Use the identifier editors already use — `go`, `python`, `rust`, `typescript`, `plaintext` —
+   * rather than inventing a spelling. Anyone can register a language, so the set is open by
+   * definition and only a shared convention keeps one language from arriving under three names.
+   *
+   * NOTICE: the list is VS Code's. The Language Server Protocol shares it for the languages it
+   * covers, but its table has no entry for plain text, so `plaintext` comes from VS Code alone.
+   * https://code.visualstudio.com/docs/languages/identifiers
+   * https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocumentItem
+   */
+  name: string;
+}
+interface PluginDefinition<Rules extends Record<string, RuleDefinition<any>> = Record<string, RuleDefinition<any>>> {
+  configs?: Record<string, AlintConfigInput>;
+  languages?: Record<string, LanguageDefinition>;
+  processors?: Record<string, ProcessorDefinition>;
+  rules?: Rules;
+}
+interface ProcessorDefinition {
+  postprocess?: (diagnostics: DiagnosticDescriptor[], context: ProcessorPostprocessContext) => Awaitable<DiagnosticDescriptor[]>;
+  preprocess: (file: SourceFile$1, context: ProcessorContext) => Awaitable<ProcessedSource[]>;
+}
+interface ProjectFileEntry extends BaseSourceFile {
+  targetCount: number;
+}
+interface ProjectTarget {
+  files: readonly ProjectFileEntry[];
+  kind: 'project';
+  root: string;
+  targets: readonly ProjectTargetEntry[];
+}
+interface ProjectTargetEntry {
+  filePath: string;
+  identity: string;
+  kind: string;
+  name?: string;
+  range?: SourceRange;
+}
+type RuleCacheConfig = boolean | {
+  level?: 'target';
+};
+type RuleConfigEntry<Options extends readonly unknown[] = readonly []> = readonly [RuleSeverity, ...Partial<Options>] | RuleSeverity;
+interface RuleContext<Options extends readonly unknown[] = readonly []> {
+  agent?: AgentAdapter;
+  cwd: string;
+  id: string;
+  localId: string;
+  logger: {
+    debug: (...args: unknown[]) => void;
+  };
+  metering: {
+    recordUsage: (usage: RuleInferenceUsageRecord) => void;
+  };
+  model: (selector?: ModelRequirement | string) => Promise<ResolvedModel>;
+  options: Options;
+  outputLanguage?: string;
+  report: (diagnostic: DiagnosticDescriptor) => void;
+  settings: Record<string, unknown>;
+  /**
+   * Cancels the run. Forward it to anything long-running a rule starts, so cancelling stops
+   * the work instead of letting it finish and bill.
+   *
+   * `ctx.agent` already injects it, and `generateStructured` accepts it as `signal`.
+   */
+  signal?: AbortSignal;
+  src: SourceRuntime;
+}
+interface RuleDefinition<OptionsSchema extends RuleOptionsSchema = []> {
+  cache?: RuleCacheConfig;
+  /** Additional stable rule inputs, such as imported prompts, that invalidate cached results when changed. */
+  cacheKey?: unknown;
+  create: (context: RuleContext<RuleOptionsOutput<OptionsSchema>>) => RuleHandlers;
+  /**
+   * Which languages this rule reads. Omitting it opts out of extraction: the rule still receives
+   * file targets, but never the function and class targets a language produces.
+   *
+   * It does not choose how a file is parsed. A config's `language:` pin, or the extension, settles
+   * that before any rule is consulted. Directory and project targets ignore it too: they index a
+   * tree rather than come from a language.
+   */
+  languages?: RuleLanguages;
+  model?: ModelRequirement;
+  options?: OptionsSchema;
+}
+type RuleHandlers = RuleSpecializedHandlers | RuleWithHandler;
+interface RuleInferenceUsageRecord {
+  filePath?: string;
+  inputTokens?: number;
+  metadata?: unknown;
+  modelId: string;
+  outputTokens?: number;
+  providerId: string;
+  ruleId?: string;
+  totalTokens?: number;
+}
+/**
+ * - `'any'` — every registered language, and never a failure. A rule that works from `FunctionInfo`
+ *   alone wants this: a language pack the user installs later is covered without a new release.
+ * - A list of language ids — `LanguageDefinition.name` values such as `go` or `typescript`, never
+ *   file extensions. The rule handles exactly these. Files of other languages are skipped
+ *   rather than failed, so one plugin can carry rules for several languages behind one `files:`
+ *   glob. If a listed language is not registered at all the run fails, because a rule scoped to a
+ *   language nothing provides would otherwise skip every file in silence.
+ * - `{ ids: string[], skipMissing?: boolean }` — the same scoping, but an unregistered id can be
+ *   skipped instead of failing. For a plugin whose rules span languages a given user may not have installed.
+ */
+type RuleLanguages = 'any' | readonly string[] | {
+  /** Language ids this rule applies to. */
+  ids: readonly string[];
+  /** Whether to skip unregistered languages instead of failing. */
+  skipMissing?: boolean;
+};
+type RuleOptionsOutput<OptionsSchema extends RuleOptionsSchema> = { readonly [Index in keyof OptionsSchema]: InferOutput<OptionsSchema[Index]>; };
+type RuleOptionsSchema = readonly GenericSchema[];
+type RuleSeverity = 'error' | 'off' | 'warn';
+interface RuleSpecializedHandlers {
+  onTargetClass?: (target: ClassTarget) => Awaitable<void>;
+  onTargetDirectory?: (target: DirectoryTarget) => Awaitable<void>;
+  onTargetFile?: (target: FileTarget) => Awaitable<void>;
+  onTargetFunction?: (target: FunctionTarget) => Awaitable<void>;
+  onTargetProject?: (target: ProjectTarget) => Awaitable<void>;
+  onTargetWith?: never;
+}
+interface RuleWithHandler {
+  onTargetClass?: never;
+  onTargetDirectory?: never;
+  onTargetFile?: never;
+  onTargetFunction?: never;
+  onTargetProject?: never;
+  onTargetWith: (target: Target) => Awaitable<void>;
+}
+type Target = DirectoryTarget | PlannedSourceTarget | ProjectTarget;
+//#endregion
+//#region src/extract.d.ts
+/**
+ * One file target carrying every call site, then one function target per function, each with the
+ * `FunctionInfo` a consumer would otherwise need its own parser to work out.
+ *
+ * The language comes from the file rather than a second argument, because every target carries that
+ * same file and the two could then disagree. Pass the file through `withLanguage` first.
+ */
+declare function extractTargets(file: SourceFile): Promise<SourceTarget[]>;
+//#endregion
+//#region src/index.d.ts
+declare const goLanguage: LanguageDefinition;
+declare const pythonLanguage: LanguageDefinition;
+declare const rustLanguage: LanguageDefinition;
+/**
+ * A plugin that declares languages and nothing else: no rules, no processors.
+ *
+ * The alias a config registers it under does not matter, because languages register under their own
+ * names. Once registered, they serve every plugin's rules, not just this one's.
+ */
+declare const languagesPlugin: PluginDefinition<Record<string, RuleDefinition<any>>>;
+//#endregion
+export { languagesPlugin as default, languagesPlugin, extractTargets, goLanguage, pythonLanguage, rustLanguage };