import { z } from 'zod';

declare enum PackageKind {
	App = "app",
	Service = "service",
	Lib = "lib",
	Cli = "cli"
}
declare enum SymbolKind {
	Function = "function",
	Class = "class",
	Interface = "interface",
	Variable = "variable",
	Type = "type",
	Enum = "enum",
	Component = "component",
	Prop = "prop",
	Method = "method",
	Endpoint = "endpoint",
	Config = "config",
	Hook = "hook",
	Process = "process"
}
declare enum Grounding {
	Code = "code",
	Concept = "concept"
}
declare enum Visibility {
	Exported = "exported",
	Public = "public",
	Protected = "protected",
	Internal = "internal"
}
declare enum EdgeType {
	Contains = "contains",
	Imports = "imports",
	ImportsType = "imports_type",
	Calls = "calls",
	Extends = "extends",
	Implements = "implements",
	ParamType = "param_type",
	ReturnType = "return_type",
	OfType = "of_type",
	DependsOn = "depends_on",
	RelatedTo = "related_to",
	Corresponds = "corresponds",
	Refines = "refines",
	AnchoredTo = "anchored_to",
	Supersedes = "supersedes",
	Conflicts = "conflicts",
	References = "references"
}
declare enum EdgeSource {
	Ast = "ast",
	Doc = "doc",
	Manual = "manual"
}
declare const indexerEvidenceAdapterResultSchema: z.ZodEffects<z.ZodObject<{
	protocol: z.ZodLiteral<"context.indexer.evidence-adapter-result/v1">;
	adapter: z.ZodObject<{
		id: z.ZodEffects<z.ZodString, string, string>;
		package: z.ZodString;
		export: z.ZodString;
		version: z.ZodString;
		digest: z.ZodString;
	}, "strict", z.ZodTypeAny, {
		package: string;
		id: string;
		version: string;
		digest: string;
		export: string;
	}, {
		package: string;
		id: string;
		version: string;
		digest: string;
		export: string;
	}>;
	authorized_scope: z.ZodObject<{
		source_ref: z.ZodString;
		module_refs: z.ZodArray<z.ZodString, "many">;
		scope_digest: z.ZodString;
	}, "strict", z.ZodTypeAny, {
		source_ref: string;
		module_refs: string[];
		scope_digest: string;
	}, {
		source_ref: string;
		module_refs: string[];
		scope_digest: string;
	}>;
	input_digest: z.ZodString;
	precedence: z.ZodNumber;
	files: z.ZodArray<z.ZodEffects<z.ZodObject<{
		file_ref: z.ZodString;
		source_ref: z.ZodString;
		module_ref: z.ZodNullable<z.ZodString>;
		normalized_path: z.ZodEffects<z.ZodString, string, string>;
		role: z.ZodEnum<[
			"primary-owner",
			"enricher"
		]>;
		coverage_tier: z.ZodEnum<[
			"ast-catalog",
			"lightweight-evidence"
		]>;
		disposition: z.ZodEnum<[
			"analyzed",
			"unsupported",
			"excluded"
		]>;
		facts: z.ZodArray<z.ZodObject<{
			fact_ref: z.ZodString;
			kind: z.ZodEffects<z.ZodString, string, string>;
			locator: z.ZodObject<{
				source_ref: z.ZodString;
				module_ref: z.ZodNullable<z.ZodString>;
				normalized_path: z.ZodEffects<z.ZodString, string, string>;
				qualified_item_path: z.ZodString;
				signature_digest: z.ZodString;
			}, "strict", z.ZodTypeAny, {
				source_ref: string;
				module_ref: string | null;
				normalized_path: string;
				qualified_item_path: string;
				signature_digest: string;
			}, {
				source_ref: string;
				module_ref: string | null;
				normalized_path: string;
				qualified_item_path: string;
				signature_digest: string;
			}>;
			payload_digest: z.ZodString;
			denominator: z.ZodEnum<[
				"none",
				"eligible-file",
				"loc",
				"symbol",
				"protocol-item"
			]>;
		}, "strict", z.ZodTypeAny, {
			kind: string;
			fact_ref: string;
			locator: {
				source_ref: string;
				module_ref: string | null;
				normalized_path: string;
				qualified_item_path: string;
				signature_digest: string;
			};
			payload_digest: string;
			denominator: "symbol" | "none" | "eligible-file" | "loc" | "protocol-item";
		}, {
			kind: string;
			fact_ref: string;
			locator: {
				source_ref: string;
				module_ref: string | null;
				normalized_path: string;
				qualified_item_path: string;
				signature_digest: string;
			};
			payload_digest: string;
			denominator: "symbol" | "none" | "eligible-file" | "loc" | "protocol-item";
		}>, "many">;
	}, "strict", z.ZodTypeAny, {
		source_ref: string;
		module_ref: string | null;
		normalized_path: string;
		file_ref: string;
		role: "primary-owner" | "enricher";
		coverage_tier: "ast-catalog" | "lightweight-evidence";
		disposition: "analyzed" | "unsupported" | "excluded";
		facts: {
			kind: string;
			fact_ref: string;
			locator: {
				source_ref: string;
				module_ref: string | null;
				normalized_path: string;
				qualified_item_path: string;
				signature_digest: string;
			};
			payload_digest: string;
			denominator: "symbol" | "none" | "eligible-file" | "loc" | "protocol-item";
		}[];
	}, {
		source_ref: string;
		module_ref: string | null;
		normalized_path: string;
		file_ref: string;
		role: "primary-owner" | "enricher";
		coverage_tier: "ast-catalog" | "lightweight-evidence";
		disposition: "analyzed" | "unsupported" | "excluded";
		facts: {
			kind: string;
			fact_ref: string;
			locator: {
				source_ref: string;
				module_ref: string | null;
				normalized_path: string;
				qualified_item_path: string;
				signature_digest: string;
			};
			payload_digest: string;
			denominator: "symbol" | "none" | "eligible-file" | "loc" | "protocol-item";
		}[];
	}>, {
		source_ref: string;
		module_ref: string | null;
		normalized_path: string;
		file_ref: string;
		role: "primary-owner" | "enricher";
		coverage_tier: "ast-catalog" | "lightweight-evidence";
		disposition: "analyzed" | "unsupported" | "excluded";
		facts: {
			kind: string;
			fact_ref: string;
			locator: {
				source_ref: string;
				module_ref: string | null;
				normalized_path: string;
				qualified_item_path: string;
				signature_digest: string;
			};
			payload_digest: string;
			denominator: "symbol" | "none" | "eligible-file" | "loc" | "protocol-item";
		}[];
	}, {
		source_ref: string;
		module_ref: string | null;
		normalized_path: string;
		file_ref: string;
		role: "primary-owner" | "enricher";
		coverage_tier: "ast-catalog" | "lightweight-evidence";
		disposition: "analyzed" | "unsupported" | "excluded";
		facts: {
			kind: string;
			fact_ref: string;
			locator: {
				source_ref: string;
				module_ref: string | null;
				normalized_path: string;
				qualified_item_path: string;
				signature_digest: string;
			};
			payload_digest: string;
			denominator: "symbol" | "none" | "eligible-file" | "loc" | "protocol-item";
		}[];
	}>, "many">;
	diagnostics: z.ZodArray<z.ZodObject<{
		code: z.ZodEffects<z.ZodString, string, string>;
		fact_ref: z.ZodOptional<z.ZodString>;
		severity: z.ZodEnum<[
			"info",
			"warning",
			"error"
		]>;
		detail_digest: z.ZodString;
	}, "strict", z.ZodTypeAny, {
		code: string;
		severity: "warning" | "info" | "error";
		detail_digest: string;
		fact_ref?: string | undefined;
	}, {
		code: string;
		severity: "warning" | "info" | "error";
		detail_digest: string;
		fact_ref?: string | undefined;
	}>, "many">;
	toolchain: z.ZodArray<z.ZodEffects<z.ZodObject<{
		step: z.ZodEffects<z.ZodString, string, string>;
		package: z.ZodString;
		export: z.ZodString;
		version: z.ZodString;
		digest: z.ZodString;
		capabilities: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
		input_digest: z.ZodString;
		output_digest: z.ZodString;
	}, "strict", z.ZodTypeAny, {
		package: string;
		version: string;
		digest: string;
		export: string;
		step: string;
		capabilities: string[];
		input_digest: string;
		output_digest: string;
	}, {
		package: string;
		version: string;
		digest: string;
		export: string;
		step: string;
		capabilities: string[];
		input_digest: string;
		output_digest: string;
	}>, {
		package: string;
		version: string;
		digest: string;
		export: string;
		step: string;
		capabilities: string[];
		input_digest: string;
		output_digest: string;
	}, {
		package: string;
		version: string;
		digest: string;
		export: string;
		step: string;
		capabilities: string[];
		input_digest: string;
		output_digest: string;
	}>, "many">;
	output_digest: z.ZodString;
}, "strict", z.ZodTypeAny, {
	input_digest: string;
	output_digest: string;
	protocol: "context.indexer.evidence-adapter-result/v1";
	adapter: {
		package: string;
		id: string;
		version: string;
		digest: string;
		export: string;
	};
	authorized_scope: {
		source_ref: string;
		module_refs: string[];
		scope_digest: string;
	};
	precedence: number;
	files: {
		source_ref: string;
		module_ref: string | null;
		normalized_path: string;
		file_ref: string;
		role: "primary-owner" | "enricher";
		coverage_tier: "ast-catalog" | "lightweight-evidence";
		disposition: "analyzed" | "unsupported" | "excluded";
		facts: {
			kind: string;
			fact_ref: string;
			locator: {
				source_ref: string;
				module_ref: string | null;
				normalized_path: string;
				qualified_item_path: string;
				signature_digest: string;
			};
			payload_digest: string;
			denominator: "symbol" | "none" | "eligible-file" | "loc" | "protocol-item";
		}[];
	}[];
	diagnostics: {
		code: string;
		severity: "warning" | "info" | "error";
		detail_digest: string;
		fact_ref?: string | undefined;
	}[];
	toolchain: {
		package: string;
		version: string;
		digest: string;
		export: string;
		step: string;
		capabilities: string[];
		input_digest: string;
		output_digest: string;
	}[];
}, {
	input_digest: string;
	output_digest: string;
	protocol: "context.indexer.evidence-adapter-result/v1";
	adapter: {
		package: string;
		id: string;
		version: string;
		digest: string;
		export: string;
	};
	authorized_scope: {
		source_ref: string;
		module_refs: string[];
		scope_digest: string;
	};
	precedence: number;
	files: {
		source_ref: string;
		module_ref: string | null;
		normalized_path: string;
		file_ref: string;
		role: "primary-owner" | "enricher";
		coverage_tier: "ast-catalog" | "lightweight-evidence";
		disposition: "analyzed" | "unsupported" | "excluded";
		facts: {
			kind: string;
			fact_ref: string;
			locator: {
				source_ref: string;
				module_ref: string | null;
				normalized_path: string;
				qualified_item_path: string;
				signature_digest: string;
			};
			payload_digest: string;
			denominator: "symbol" | "none" | "eligible-file" | "loc" | "protocol-item";
		}[];
	}[];
	diagnostics: {
		code: string;
		severity: "warning" | "info" | "error";
		detail_digest: string;
		fact_ref?: string | undefined;
	}[];
	toolchain: {
		package: string;
		version: string;
		digest: string;
		export: string;
		step: string;
		capabilities: string[];
		input_digest: string;
		output_digest: string;
	}[];
}>, {
	input_digest: string;
	output_digest: string;
	protocol: "context.indexer.evidence-adapter-result/v1";
	adapter: {
		package: string;
		id: string;
		version: string;
		digest: string;
		export: string;
	};
	authorized_scope: {
		source_ref: string;
		module_refs: string[];
		scope_digest: string;
	};
	precedence: number;
	files: {
		source_ref: string;
		module_ref: string | null;
		normalized_path: string;
		file_ref: string;
		role: "primary-owner" | "enricher";
		coverage_tier: "ast-catalog" | "lightweight-evidence";
		disposition: "analyzed" | "unsupported" | "excluded";
		facts: {
			kind: string;
			fact_ref: string;
			locator: {
				source_ref: string;
				module_ref: string | null;
				normalized_path: string;
				qualified_item_path: string;
				signature_digest: string;
			};
			payload_digest: string;
			denominator: "symbol" | "none" | "eligible-file" | "loc" | "protocol-item";
		}[];
	}[];
	diagnostics: {
		code: string;
		severity: "warning" | "info" | "error";
		detail_digest: string;
		fact_ref?: string | undefined;
	}[];
	toolchain: {
		package: string;
		version: string;
		digest: string;
		export: string;
		step: string;
		capabilities: string[];
		input_digest: string;
		output_digest: string;
	}[];
}, {
	input_digest: string;
	output_digest: string;
	protocol: "context.indexer.evidence-adapter-result/v1";
	adapter: {
		package: string;
		id: string;
		version: string;
		digest: string;
		export: string;
	};
	authorized_scope: {
		source_ref: string;
		module_refs: string[];
		scope_digest: string;
	};
	precedence: number;
	files: {
		source_ref: string;
		module_ref: string | null;
		normalized_path: string;
		file_ref: string;
		role: "primary-owner" | "enricher";
		coverage_tier: "ast-catalog" | "lightweight-evidence";
		disposition: "analyzed" | "unsupported" | "excluded";
		facts: {
			kind: string;
			fact_ref: string;
			locator: {
				source_ref: string;
				module_ref: string | null;
				normalized_path: string;
				qualified_item_path: string;
				signature_digest: string;
			};
			payload_digest: string;
			denominator: "symbol" | "none" | "eligible-file" | "loc" | "protocol-item";
		}[];
	}[];
	diagnostics: {
		code: string;
		severity: "warning" | "info" | "error";
		detail_digest: string;
		fact_ref?: string | undefined;
	}[];
	toolchain: {
		package: string;
		version: string;
		digest: string;
		export: string;
		step: string;
		capabilities: string[];
		input_digest: string;
		output_digest: string;
	}[];
}>;
type IndexerEvidenceAdapterResult = z.infer<typeof indexerEvidenceAdapterResultSchema>;
type IndexerEvidenceAdapterFactPayloadValue = null | boolean | number | string | IndexerEvidenceAdapterFactPayloadValue[] | {
	[key: string]: IndexerEvidenceAdapterFactPayloadValue;
};
interface IndexerEvidenceAdapterFactPayload {
	fact_ref: string;
	payload: IndexerEvidenceAdapterFactPayloadValue;
}
interface IndexerEvidenceAdapterMaterialization {
	result: IndexerEvidenceAdapterResult;
	fact_payloads: IndexerEvidenceAdapterFactPayload[];
}
declare const symbolParamSchema: z.ZodObject<{
	name: z.ZodString;
	type: z.ZodNullable<z.ZodString>;
	optional: z.ZodOptional<z.ZodBoolean>;
	rest: z.ZodOptional<z.ZodBoolean>;
	defaultValue: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
	type: string | null;
	name: string;
	optional?: boolean | undefined;
	rest?: boolean | undefined;
	defaultValue?: string | undefined;
}, {
	type: string | null;
	name: string;
	optional?: boolean | undefined;
	rest?: boolean | undefined;
	defaultValue?: string | undefined;
}>;
declare const registrationSchema: z.ZodObject<{
	kind: z.ZodEnum<[
		"http",
		"schedule",
		"event"
	]>;
	key: z.ZodString;
	handler: z.ZodString;
	method: z.ZodOptional<z.ZodString>;
	middleware: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
	key: string;
	kind: "http" | "schedule" | "event";
	handler: string;
	middleware: string[];
	method?: string | undefined;
}, {
	key: string;
	kind: "http" | "schedule" | "event";
	handler: string;
	middleware: string[];
	method?: string | undefined;
}>;
type SymbolInfo = {
	name: string;
	kind: SymbolKind;
	visibility: Visibility;
	file: string;
	line: number;
	endLine: number;
	members?: SymbolInfo[] | undefined;
	params?: z.infer<typeof symbolParamSchema>[] | undefined;
	optional?: boolean | undefined;
	readonly?: boolean | undefined;
	defaultValue?: string | undefined;
	typeParameters?: string | undefined;
	overloads?: string[] | undefined;
	publicEntrypoints?: string[] | undefined;
	contractResolution?: "resolved" | "declaration-only" | undefined;
	registration?: z.infer<typeof registrationSchema> | undefined;
	returnType?: string | null | undefined;
	typeAnnotation?: string | null | undefined;
	extends?: string | null | undefined;
	implements?: string[] | undefined;
	doc?: string | null | undefined;
	propsType?: string | null | undefined;
	unionValues?: string[] | undefined;
	initializer?: string | null | undefined;
	signature?: string | null | undefined;
};
declare const extractionResultSchema: z.ZodObject<{
	version: z.ZodLiteral<"2">;
	meta: z.ZodObject<{
		extractedAt: z.ZodString;
		pluginId: z.ZodString;
		commitHash: z.ZodNullable<z.ZodString>;
		language: z.ZodString;
	}, "strip", z.ZodTypeAny, {
		language: string;
		extractedAt: string;
		pluginId: string;
		commitHash: string | null;
	}, {
		language: string;
		extractedAt: string;
		pluginId: string;
		commitHash: string | null;
	}>;
	package: z.ZodObject<{
		name: z.ZodString;
		kind: z.ZodEnum<[
			PackageKind,
			...PackageKind[]
		]>;
		language: z.ZodString;
		version: z.ZodOptional<z.ZodString>;
	}, "strip", z.ZodTypeAny, {
		name: string;
		kind: PackageKind;
		language: string;
		version?: string | undefined;
	}, {
		name: string;
		kind: PackageKind;
		language: string;
		version?: string | undefined;
	}>;
	files: z.ZodArray<z.ZodObject<{
		path: z.ZodString;
		language: z.ZodString;
		lines: z.ZodNumber;
	}, "strip", z.ZodTypeAny, {
		path: string;
		language: string;
		lines: number;
	}, {
		path: string;
		language: string;
		lines: number;
	}>, "many">;
	symbols: z.ZodArray<z.ZodType<SymbolInfo, z.ZodTypeDef, SymbolInfo>, "many">;
	relations: z.ZodArray<z.ZodObject<{
		type: z.ZodEnum<[
			EdgeType.Imports,
			EdgeType.ImportsType,
			EdgeType.Calls,
			EdgeType.Extends,
			EdgeType.Implements,
			EdgeType.ParamType,
			EdgeType.ReturnType,
			EdgeType.OfType,
			EdgeType.DependsOn,
			EdgeType.Contains
		]>;
		from: z.ZodString;
		to: z.ZodString;
		file: z.ZodOptional<z.ZodString>;
		isExternal: z.ZodBoolean;
		grounding: z.ZodEnum<[
			Grounding,
			...Grounding[]
		]>;
		confidence: z.ZodNumber;
		source: z.ZodEnum<[
			EdgeSource.Ast,
			EdgeSource.Doc,
			EdgeSource.Manual
		]>;
		line: z.ZodOptional<z.ZodNumber>;
	}, "strip", z.ZodTypeAny, {
		type: EdgeType.Contains | EdgeType.Imports | EdgeType.ImportsType | EdgeType.Calls | EdgeType.Extends | EdgeType.Implements | EdgeType.ParamType | EdgeType.ReturnType | EdgeType.OfType | EdgeType.DependsOn;
		confidence: number;
		from: string;
		to: string;
		grounding: Grounding;
		source: EdgeSource;
		isExternal: boolean;
		file?: string | undefined;
		line?: number | undefined;
	}, {
		type: EdgeType.Contains | EdgeType.Imports | EdgeType.ImportsType | EdgeType.Calls | EdgeType.Extends | EdgeType.Implements | EdgeType.ParamType | EdgeType.ReturnType | EdgeType.OfType | EdgeType.DependsOn;
		confidence: number;
		from: string;
		to: string;
		grounding: Grounding;
		source: EdgeSource;
		isExternal: boolean;
		file?: string | undefined;
		line?: number | undefined;
	}>, "many">;
	coverage: z.ZodOptional<z.ZodObject<{
		tier: z.ZodEnum<[
			"ast-catalog",
			"lightweight-evidence"
		]>;
		capabilities: z.ZodArray<z.ZodString, "many">;
		files: z.ZodArray<z.ZodObject<{
			path: z.ZodString;
			disposition: z.ZodEnum<[
				"analyzed",
				"unsupported",
				"excluded"
			]>;
			diagnosticCodes: z.ZodArray<z.ZodString, "many">;
		}, "strip", z.ZodTypeAny, {
			path: string;
			disposition: "analyzed" | "unsupported" | "excluded";
			diagnosticCodes: string[];
		}, {
			path: string;
			disposition: "analyzed" | "unsupported" | "excluded";
			diagnosticCodes: string[];
		}>, "many">;
		diagnostics: z.ZodArray<z.ZodObject<{
			code: z.ZodString;
			severity: z.ZodEnum<[
				"info",
				"warning",
				"error"
			]>;
			file: z.ZodString;
			line: z.ZodNumber;
			column: z.ZodNumber;
		}, "strip", z.ZodTypeAny, {
			code: string;
			severity: "warning" | "info" | "error";
			file: string;
			line: number;
			column: number;
		}, {
			code: string;
			severity: "warning" | "info" | "error";
			file: string;
			line: number;
			column: number;
		}>, "many">;
	}, "strip", z.ZodTypeAny, {
		capabilities: string[];
		files: {
			path: string;
			disposition: "analyzed" | "unsupported" | "excluded";
			diagnosticCodes: string[];
		}[];
		diagnostics: {
			code: string;
			severity: "warning" | "info" | "error";
			file: string;
			line: number;
			column: number;
		}[];
		tier: "ast-catalog" | "lightweight-evidence";
	}, {
		capabilities: string[];
		files: {
			path: string;
			disposition: "analyzed" | "unsupported" | "excluded";
			diagnosticCodes: string[];
		}[];
		diagnostics: {
			code: string;
			severity: "warning" | "info" | "error";
			file: string;
			line: number;
			column: number;
		}[];
		tier: "ast-catalog" | "lightweight-evidence";
	}>>;
	stats: z.ZodObject<{
		files: z.ZodNumber;
		lines: z.ZodNumber;
		exportedSymbols: z.ZodNumber;
		internalSymbols: z.ZodNumber;
		relations: z.ZodNumber;
	}, "strip", z.ZodTypeAny, {
		relations: number;
		files: number;
		lines: number;
		exportedSymbols: number;
		internalSymbols: number;
	}, {
		relations: number;
		files: number;
		lines: number;
		exportedSymbols: number;
		internalSymbols: number;
	}>;
}, "strip", z.ZodTypeAny, {
	package: {
		name: string;
		kind: PackageKind;
		language: string;
		version?: string | undefined;
	};
	relations: {
		type: EdgeType.Contains | EdgeType.Imports | EdgeType.ImportsType | EdgeType.Calls | EdgeType.Extends | EdgeType.Implements | EdgeType.ParamType | EdgeType.ReturnType | EdgeType.OfType | EdgeType.DependsOn;
		confidence: number;
		from: string;
		to: string;
		grounding: Grounding;
		source: EdgeSource;
		isExternal: boolean;
		file?: string | undefined;
		line?: number | undefined;
	}[];
	version: "2";
	files: {
		path: string;
		language: string;
		lines: number;
	}[];
	meta: {
		language: string;
		extractedAt: string;
		pluginId: string;
		commitHash: string | null;
	};
	symbols: SymbolInfo[];
	stats: {
		relations: number;
		files: number;
		lines: number;
		exportedSymbols: number;
		internalSymbols: number;
	};
	coverage?: {
		capabilities: string[];
		files: {
			path: string;
			disposition: "analyzed" | "unsupported" | "excluded";
			diagnosticCodes: string[];
		}[];
		diagnostics: {
			code: string;
			severity: "warning" | "info" | "error";
			file: string;
			line: number;
			column: number;
		}[];
		tier: "ast-catalog" | "lightweight-evidence";
	} | undefined;
}, {
	package: {
		name: string;
		kind: PackageKind;
		language: string;
		version?: string | undefined;
	};
	relations: {
		type: EdgeType.Contains | EdgeType.Imports | EdgeType.ImportsType | EdgeType.Calls | EdgeType.Extends | EdgeType.Implements | EdgeType.ParamType | EdgeType.ReturnType | EdgeType.OfType | EdgeType.DependsOn;
		confidence: number;
		from: string;
		to: string;
		grounding: Grounding;
		source: EdgeSource;
		isExternal: boolean;
		file?: string | undefined;
		line?: number | undefined;
	}[];
	version: "2";
	files: {
		path: string;
		language: string;
		lines: number;
	}[];
	meta: {
		language: string;
		extractedAt: string;
		pluginId: string;
		commitHash: string | null;
	};
	symbols: SymbolInfo[];
	stats: {
		relations: number;
		files: number;
		lines: number;
		exportedSymbols: number;
		internalSymbols: number;
	};
	coverage?: {
		capabilities: string[];
		files: {
			path: string;
			disposition: "analyzed" | "unsupported" | "excluded";
			diagnosticCodes: string[];
		}[];
		diagnostics: {
			code: string;
			severity: "warning" | "info" | "error";
			file: string;
			line: number;
			column: number;
		}[];
		tier: "ast-catalog" | "lightweight-evidence";
	} | undefined;
}>;
type ExtractionResult = z.infer<typeof extractionResultSchema>;
declare const entryFileSchema: z.ZodObject<{
	path: z.ZodString;
	subpath: z.ZodString;
	type: z.ZodEnum<[
		"library",
		"cli",
		"service",
		"webapp"
	]>;
}, "strip", z.ZodTypeAny, {
	type: "service" | "cli" | "library" | "webapp";
	path: string;
	subpath: string;
}, {
	type: "service" | "cli" | "library" | "webapp";
	path: string;
	subpath: string;
}>;
declare const manifestInfoSchema: z.ZodObject<{
	type: z.ZodEnum<[
		"package.json",
		"pyproject.toml",
		"Cargo.toml",
		"go.mod",
		"pom.xml"
	]>;
	path: z.ZodString;
	content: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, "strip", z.ZodTypeAny, {
	type: "package.json" | "go.mod" | "pyproject.toml" | "Cargo.toml" | "pom.xml";
	content: Record<string, unknown>;
	path: string;
}, {
	type: "package.json" | "go.mod" | "pyproject.toml" | "Cargo.toml" | "pom.xml";
	content: Record<string, unknown>;
	path: string;
}>;
declare const sourceInfoSchema: z.ZodObject<{
	path: z.ZodString;
	manifests: z.ZodArray<z.ZodObject<{
		type: z.ZodEnum<[
			"package.json",
			"pyproject.toml",
			"Cargo.toml",
			"go.mod",
			"pom.xml"
		]>;
		path: z.ZodString;
		content: z.ZodRecord<z.ZodString, z.ZodUnknown>;
	}, "strip", z.ZodTypeAny, {
		type: "package.json" | "go.mod" | "pyproject.toml" | "Cargo.toml" | "pom.xml";
		content: Record<string, unknown>;
		path: string;
	}, {
		type: "package.json" | "go.mod" | "pyproject.toml" | "Cargo.toml" | "pom.xml";
		content: Record<string, unknown>;
		path: string;
	}>, "many">;
	language: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
	path: string;
	manifests: {
		type: "package.json" | "go.mod" | "pyproject.toml" | "Cargo.toml" | "pom.xml";
		content: Record<string, unknown>;
		path: string;
	}[];
	language?: string | undefined;
}, {
	path: string;
	manifests: {
		type: "package.json" | "go.mod" | "pyproject.toml" | "Cargo.toml" | "pom.xml";
		content: Record<string, unknown>;
		path: string;
	}[];
	language?: string | undefined;
}>;
declare const patternDetectionResultSchema: z.ZodObject<{
	endpoints: z.ZodOptional<z.ZodArray<z.ZodObject<{
		handler: z.ZodString;
		method: z.ZodString;
		path: z.ZodString;
		file: z.ZodString;
		line: z.ZodNumber;
	}, "strip", z.ZodTypeAny, {
		method: string;
		path: string;
		handler: string;
		file: string;
		line: number;
	}, {
		method: string;
		path: string;
		handler: string;
		file: string;
		line: number;
	}>, "many">>;
	implicitDeps: z.ZodOptional<z.ZodArray<z.ZodObject<{
		verb: z.ZodEnum<[
			"produce",
			"consume",
			"depends_on",
			"serve"
		]>;
		target: z.ZodString;
		file: z.ZodString;
		line: z.ZodNumber;
	}, "strip", z.ZodTypeAny, {
		target: string;
		file: string;
		line: number;
		verb: "depends_on" | "produce" | "consume" | "serve";
	}, {
		target: string;
		file: string;
		line: number;
		verb: "depends_on" | "produce" | "consume" | "serve";
	}>, "many">>;
	configRefs: z.ZodOptional<z.ZodArray<z.ZodObject<{
		key: z.ZodString;
		file: z.ZodString;
		line: z.ZodNumber;
	}, "strip", z.ZodTypeAny, {
		key: string;
		file: string;
		line: number;
	}, {
		key: string;
		file: string;
		line: number;
	}>, "many">>;
}, "strip", z.ZodTypeAny, {
	endpoints?: {
		method: string;
		path: string;
		handler: string;
		file: string;
		line: number;
	}[] | undefined;
	implicitDeps?: {
		target: string;
		file: string;
		line: number;
		verb: "depends_on" | "produce" | "consume" | "serve";
	}[] | undefined;
	configRefs?: {
		key: string;
		file: string;
		line: number;
	}[] | undefined;
}, {
	endpoints?: {
		method: string;
		path: string;
		handler: string;
		file: string;
		line: number;
	}[] | undefined;
	implicitDeps?: {
		target: string;
		file: string;
		line: number;
		verb: "depends_on" | "produce" | "consume" | "serve";
	}[] | undefined;
	configRefs?: {
		key: string;
		file: string;
		line: number;
	}[] | undefined;
}>;
type EntryFile = z.infer<typeof entryFileSchema>;
type ManifestInfo = z.infer<typeof manifestInfoSchema>;
type SourceInfo = z.infer<typeof sourceInfoSchema>;
type EntryDetectionResult = {
	package: {
		name: string;
		kind: PackageKind;
		language: string;
		version?: string | undefined;
	};
	entries: EntryFile[];
	subPackages?: EntryDetectionResult[] | undefined;
};
type PatternDetectionResult = z.infer<typeof patternDetectionResultSchema>;
interface FileSystem$1 {
	readFile(path: string): Promise<string>;
	readdir(path: string): Promise<string[]>;
	exists(path: string): Promise<boolean>;
	readJson<T = unknown>(path: string): Promise<T>;
}
interface ExtractionPlugin {
	id: string;
	languages: string[];
	packageManagers: string[];
	capabilities?: string[];
	coverageTier?: "ast-catalog" | "lightweight-evidence";
	manifestTypes?: ManifestInfo["type"][];
	canHandle(source: SourceInfo): boolean;
	detectEntries(manifest: ManifestInfo, fs: FileSystem$1): Promise<EntryDetectionResult>;
	extractSymbols(entries: EntryFile[], fs: FileSystem$1): Promise<ExtractionResult>;
	detectPatterns?(fs: FileSystem$1): Promise<PatternDetectionResult>;
}
interface ExtractionEvidenceAdapterInvocation {
	adapter: IndexerEvidenceAdapterResult["adapter"];
	authorized_scope: IndexerEvidenceAdapterResult["authorized_scope"];
	module_ref: string | null;
	input_digest: string;
	precedence: number;
	role?: "primary-owner" | "enricher";
	/** Already scoped source text; used only for physical file extents, never persisted. */
	source_files?: Readonly<Record<string, string>>;
}
export declare class GoPlugin implements ExtractionPlugin {
	#private;
	readonly id = "c4a-extract-go";
	readonly languages: string[];
	readonly packageManagers: string[];
	readonly coverageTier: "ast-catalog";
	readonly capabilities: string[];
	readonly manifestTypes: ManifestInfo["type"][];
	canHandle(source: SourceInfo): boolean;
	detectEntries(manifest: ManifestInfo, fs: FileSystem$1): Promise<EntryDetectionResult>;
	extractSymbols(entries: EntryFile[], fs: FileSystem$1): Promise<ExtractionResult>;
}
export type GoSymbolKind = "struct" | "interface" | "type" | "function" | "method" | "const" | "var";
export interface GoSourceLocation {
	path: string;
	startLine: number;
	startColumn: number;
	endLine: number;
	endColumn: number;
}
export interface GoImport {
	alias: string;
	path: string;
	location?: GoSourceLocation;
}
export interface GoSymbol {
	id: string;
	kind: GoSymbolKind;
	name: string;
	qualifiedName: string;
	package: string;
	receiver?: string;
	exported: boolean;
	signature: string;
	fields?: Array<{
		name: string;
		type: string;
		tag?: string;
		embedded: boolean;
		location: GoSourceLocation;
	}>;
	parameters?: Array<{
		name: string;
		type: string;
		optional: boolean;
		rest: boolean;
	}>;
	results?: Array<{
		name: string;
		type: string;
	}>;
	doc?: string;
	location: GoSourceLocation;
}
export interface GoCall {
	id: string;
	callee: string;
	selectorPath: string[];
	receiver?: string;
	method: string;
	arguments: string[];
	assignedTo?: string;
	importPath?: string;
	enclosingSymbol?: string;
	location: GoSourceLocation;
}
export type GoHttpFramework = "net-http" | "hertz" | "gin" | "echo" | "chi" | "unknown";
export interface GoHttpRoute {
	id: string;
	framework: GoHttpFramework;
	method: string;
	path: string;
	handler: string;
	receiver: string;
	arguments: string[];
	middleware: string[];
	enclosingSymbol?: string;
	location: GoSourceLocation;
}
export interface GoFileIndex {
	path: string;
	package: string;
	imports: GoImport[];
	symbols: GoSymbol[];
	calls: GoCall[];
	routes: GoHttpRoute[];
	parseErrors: number;
	lines: number;
}
export interface GoIndexOptions {
	exportedOnly?: boolean;
	includeTests?: boolean;
	includeGenerated?: boolean;
	include?: readonly string[];
	excludeDirectories?: readonly string[];
}
export interface GoRepositoryStats {
	discoveredFiles: number;
	analyzedFiles: number;
	skippedTestFiles: number;
	skippedGeneratedFiles: number;
	parseErrors: number;
	symbols: number;
	calls: number;
	routes: number;
}
export interface GoRepositoryIndex {
	root: string;
	options: {
		exportedOnly: boolean;
		includeTests: boolean;
		includeGenerated: boolean;
		include: string[];
		excludeDirectories: string[];
	};
	stats: GoRepositoryStats;
	files: GoFileIndex[];
}
export declare function indexGoSource(source: string, filePath: string, options?: {
	exportedOnly?: boolean;
}): GoFileIndex;
export declare function indexGoRepository(repositoryRoot: string, options?: GoIndexOptions): Promise<GoRepositoryIndex>;
/** Converts Go ExtractionResult v2 into the common Context Evidence ABI. */
export declare function goExtractionToEvidenceAdapterResult(extraction: ExtractionResult, invocation: ExtractionEvidenceAdapterInvocation): IndexerEvidenceAdapterResult;
export declare function goExtractionToEvidenceAdapterMaterialization(extraction: ExtractionResult, invocation: ExtractionEvidenceAdapterInvocation): IndexerEvidenceAdapterMaterialization;

export {};