@c4a/context 0.6.19 → 0.7.0

package/indexerOverlayTrust.d.ts

@@ -0,0 +1,1425 @@
+import { z } from "zod";
+import { type IndexerOperatorContract, type IndexerProfileContract, type IndexerProfileContractEntry } from "./indexerProfileContract.js";
+export declare const indexerContractOverlaySchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"context.indexer.contract-overlay/v1">;
+    id: z.ZodEffects<z.ZodString, string, string>;
+    version: z.ZodString;
+    extends: z.ZodObject<{
+        profile: z.ZodEffects<z.ZodString, string, string>;
+        version: z.ZodString;
+        contract_digest: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        contract_digest: string;
+        version: string;
+        profile: string;
+    }, {
+        contract_digest: string;
+        version: string;
+        profile: string;
+    }>;
+    operator_contract_version: z.ZodString;
+    operator_contract_digest: z.ZodString;
+    additions: z.ZodObject<{
+        inventory_domains: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodEffects<z.ZodString, string, string>;
+            selector: z.ZodObject<{
+                operator: z.ZodEffects<z.ZodString, string, string>;
+                parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("./indexerRegistry.js").IndexerJson, z.ZodTypeDef, import("./indexerRegistry.js").IndexerJson>>>;
+            }, "strict", z.ZodTypeAny, {
+                operator: string;
+                parameters?: Record<string, import("./indexerRegistry.js").IndexerJson> | undefined;
+            }, {
+                operator: string;
+                parameters?: Record<string, import("./indexerRegistry.js").IndexerJson> | undefined;
+            }>;
+            disposition_required: z.ZodLiteral<true>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            selector: {
+                operator: string;
+                parameters?: Record<string, import("./indexerRegistry.js").IndexerJson> | undefined;
+            };
+            disposition_required: true;
+        }, {
+            id: string;
+            selector: {
+                operator: string;
+                parameters?: Record<string, import("./indexerRegistry.js").IndexerJson> | undefined;
+            };
+            disposition_required: true;
+        }>, "many">>;
+        required_dispositions: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+        metrics: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+            id: z.ZodEffects<z.ZodString, string, string>;
+            unit: z.ZodEnum<["count", "ratio"]>;
+            operator: z.ZodEffects<z.ZodString, string, string>;
+            threshold_policy: z.ZodLiteral<"explicit">;
+            direction: z.ZodLiteral<"minimum">;
+            recommended_min: z.ZodNumber;
+            hard_min: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "explicit";
+            direction: "minimum";
+            recommended_min: number;
+            hard_min: number;
+        }, {
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "explicit";
+            direction: "minimum";
+            recommended_min: number;
+            hard_min: number;
+        }>, {
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "explicit";
+            direction: "minimum";
+            recommended_min: number;
+            hard_min: number;
+        }, {
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "explicit";
+            direction: "minimum";
+            recommended_min: number;
+            hard_min: number;
+        }>, z.ZodEffects<z.ZodObject<{
+            id: z.ZodEffects<z.ZodString, string, string>;
+            unit: z.ZodEnum<["count", "ratio"]>;
+            operator: z.ZodEffects<z.ZodString, string, string>;
+            threshold_policy: z.ZodLiteral<"explicit">;
+            direction: z.ZodLiteral<"maximum">;
+            recommended_max: z.ZodNumber;
+            hard_max: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "explicit";
+            direction: "maximum";
+            recommended_max: number;
+            hard_max: number;
+        }, {
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "explicit";
+            direction: "maximum";
+            recommended_max: number;
+            hard_max: number;
+        }>, {
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "explicit";
+            direction: "maximum";
+            recommended_max: number;
+            hard_max: number;
+        }, {
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "explicit";
+            direction: "maximum";
+            recommended_max: number;
+            hard_max: number;
+        }>, z.ZodObject<{
+            id: z.ZodEffects<z.ZodString, string, string>;
+            unit: z.ZodEnum<["count", "ratio"]>;
+            operator: z.ZodEffects<z.ZodString, string, string>;
+            threshold_policy: z.ZodLiteral<"inflation-sensitive">;
+            direction: z.ZodLiteral<"maximum">;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "inflation-sensitive";
+            direction: "maximum";
+        }, {
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "inflation-sensitive";
+            direction: "maximum";
+        }>]>, "many">>;
+        artifact_policy_variants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodEffects<z.ZodString, string, string>;
+            eligibility: z.ZodObject<{
+                protocol: z.ZodLiteral<"context.indexer.selector/v1">;
+                expression: z.ZodType<import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression, z.ZodTypeDef, import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression>;
+            }, "strict", z.ZodTypeAny, {
+                protocol: "context.indexer.selector/v1";
+                expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+            }, {
+                protocol: "context.indexer.selector/v1";
+                expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+            }>;
+            artifact_kinds: z.ZodEffects<z.ZodObject<{
+                required: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+                discretionary: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+            }, "strict", z.ZodTypeAny, {
+                required: string[];
+                discretionary: string[];
+            }, {
+                required: string[];
+                discretionary: string[];
+            }>, {
+                required: string[];
+                discretionary: string[];
+            }, {
+                required: string[];
+                discretionary: string[];
+            }>;
+            thresholds: z.ZodRecord<z.ZodEffects<z.ZodString, string, string>, z.ZodObject<{
+                recommended_max: z.ZodNumber;
+            }, "strict", z.ZodTypeAny, {
+                recommended_max: number;
+            }, {
+                recommended_max: number;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            thresholds: Record<string, {
+                recommended_max: number;
+            }>;
+            eligibility: {
+                protocol: "context.indexer.selector/v1";
+                expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+            };
+            artifact_kinds: {
+                required: string[];
+                discretionary: string[];
+            };
+        }, {
+            id: string;
+            thresholds: Record<string, {
+                recommended_max: number;
+            }>;
+            eligibility: {
+                protocol: "context.indexer.selector/v1";
+                expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+            };
+            artifact_kinds: {
+                required: string[];
+                discretionary: string[];
+            };
+        }>, "many">>;
+        question_target_domains: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodEffects<z.ZodString, string, string>;
+            selector: z.ZodObject<{
+                operator: z.ZodEffects<z.ZodString, string, string>;
+                parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("./indexerRegistry.js").IndexerJson, z.ZodTypeDef, import("./indexerRegistry.js").IndexerJson>>>;
+            }, "strict", z.ZodTypeAny, {
+                operator: string;
+                parameters?: Record<string, import("./indexerRegistry.js").IndexerJson> | undefined;
+            }, {
+                operator: string;
+                parameters?: Record<string, import("./indexerRegistry.js").IndexerJson> | undefined;
+            }>;
+            grouping_operator: z.ZodEffects<z.ZodString, string, string>;
+            subject_key_kind: z.ZodEffects<z.ZodString, string, string>;
+            granularity: z.ZodEnum<["module", "identity"]>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            selector: {
+                operator: string;
+                parameters?: Record<string, import("./indexerRegistry.js").IndexerJson> | undefined;
+            };
+            grouping_operator: string;
+            subject_key_kind: string;
+            granularity: "module" | "identity";
+        }, {
+            id: string;
+            selector: {
+                operator: string;
+                parameters?: Record<string, import("./indexerRegistry.js").IndexerJson> | undefined;
+            };
+            grouping_operator: string;
+            subject_key_kind: string;
+            granularity: "module" | "identity";
+        }>, "many">>;
+        reader_question_contracts: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
+            ref: z.ZodString;
+            semantic: z.ZodEffects<z.ZodString, string, string>;
+            version: z.ZodNumber;
+            coverage_domain: z.ZodEffects<z.ZodString, string, string>;
+            target_domain_ref: z.ZodEffects<z.ZodString, string, string>;
+            target_selector: z.ZodObject<{
+                protocol: z.ZodLiteral<"context.indexer.selector/v1">;
+                expression: z.ZodType<import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression, z.ZodTypeDef, import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression>;
+            }, "strict", z.ZodTypeAny, {
+                protocol: "context.indexer.selector/v1";
+                expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+            }, {
+                protocol: "context.indexer.selector/v1";
+                expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+            }>;
+            evidence_contract: z.ZodObject<{
+                accepted_kinds: z.ZodArray<z.ZodEnum<["code", "contract", "configuration", "documentation", "runbook", "decision-record", "test-result", "runtime-observation", "tool-snapshot"]>, "many">;
+                minimum_items: z.ZodNumber;
+                minimum_distinct_sources: z.ZodNumber;
+                provenance_constraints: z.ZodOptional<z.ZodObject<{
+                    protocol: z.ZodLiteral<"context.indexer.selector/v1">;
+                    expression: z.ZodType<import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression, z.ZodTypeDef, import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression>;
+                }, "strict", z.ZodTypeAny, {
+                    protocol: "context.indexer.selector/v1";
+                    expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+                }, {
+                    protocol: "context.indexer.selector/v1";
+                    expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+                }>>;
+            }, "strict", z.ZodTypeAny, {
+                accepted_kinds: ("contract" | "code" | "configuration" | "documentation" | "runbook" | "decision-record" | "test-result" | "runtime-observation" | "tool-snapshot")[];
+                minimum_items: number;
+                minimum_distinct_sources: number;
+                provenance_constraints?: {
+                    protocol: "context.indexer.selector/v1";
+                    expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+                } | undefined;
+            }, {
+                accepted_kinds: ("contract" | "code" | "configuration" | "documentation" | "runbook" | "decision-record" | "test-result" | "runtime-observation" | "tool-snapshot")[];
+                minimum_items: number;
+                minimum_distinct_sources: number;
+                provenance_constraints?: {
+                    protocol: "context.indexer.selector/v1";
+                    expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+                } | undefined;
+            }>;
+            allowed_exclusion_reason_codes: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+        }, "strict", z.ZodTypeAny, {
+            ref: string;
+            version: number;
+            semantic: string;
+            coverage_domain: string;
+            target_domain_ref: string;
+            target_selector: {
+                protocol: "context.indexer.selector/v1";
+                expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+            };
+            evidence_contract: {
+                accepted_kinds: ("contract" | "code" | "configuration" | "documentation" | "runbook" | "decision-record" | "test-result" | "runtime-observation" | "tool-snapshot")[];
+                minimum_items: number;
+                minimum_distinct_sources: number;
+                provenance_constraints?: {
+                    protocol: "context.indexer.selector/v1";
+                    expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+                } | undefined;
+            };
+            allowed_exclusion_reason_codes?: string[] | undefined;
+        }, {
+            ref: string;
+            version: number;
+            semantic: string;
+            coverage_domain: string;
+            target_domain_ref: string;
+            target_selector: {
+                protocol: "context.indexer.selector/v1";
+                expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+            };
+            evidence_contract: {
+                accepted_kinds: ("contract" | "code" | "configuration" | "documentation" | "runbook" | "decision-record" | "test-result" | "runtime-observation" | "tool-snapshot")[];
+                minimum_items: number;
+                minimum_distinct_sources: number;
+                provenance_constraints?: {
+                    protocol: "context.indexer.selector/v1";
+                    expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+                } | undefined;
+            };
+            allowed_exclusion_reason_codes?: string[] | undefined;
+        }>, {
+            ref: string;
+            version: number;
+            semantic: string;
+            coverage_domain: string;
+            target_domain_ref: string;
+            target_selector: {
+                protocol: "context.indexer.selector/v1";
+                expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+            };
+            evidence_contract: {
+                accepted_kinds: ("contract" | "code" | "configuration" | "documentation" | "runbook" | "decision-record" | "test-result" | "runtime-observation" | "tool-snapshot")[];
+                minimum_items: number;
+                minimum_distinct_sources: number;
+                provenance_constraints?: {
+                    protocol: "context.indexer.selector/v1";
+                    expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+                } | undefined;
+            };
+            allowed_exclusion_reason_codes?: string[] | undefined;
+        }, {
+            ref: string;
+            version: number;
+            semantic: string;
+            coverage_domain: string;
+            target_domain_ref: string;
+            target_selector: {
+                protocol: "context.indexer.selector/v1";
+                expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+            };
+            evidence_contract: {
+                accepted_kinds: ("contract" | "code" | "configuration" | "documentation" | "runbook" | "decision-record" | "test-result" | "runtime-observation" | "tool-snapshot")[];
+                minimum_items: number;
+                minimum_distinct_sources: number;
+                provenance_constraints?: {
+                    protocol: "context.indexer.selector/v1";
+                    expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+                } | undefined;
+            };
+            allowed_exclusion_reason_codes?: string[] | undefined;
+        }>, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        metrics?: ({
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "explicit";
+            direction: "minimum";
+            recommended_min: number;
+            hard_min: number;
+        } | {
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "explicit";
+            direction: "maximum";
+            recommended_max: number;
+            hard_max: number;
+        } | {
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "inflation-sensitive";
+            direction: "maximum";
+        })[] | undefined;
+        inventory_domains?: {
+            id: string;
+            selector: {
+                operator: string;
+                parameters?: Record<string, import("./indexerRegistry.js").IndexerJson> | undefined;
+            };
+            disposition_required: true;
+        }[] | undefined;
+        required_dispositions?: string[] | undefined;
+        artifact_policy_variants?: {
+            id: string;
+            thresholds: Record<string, {
+                recommended_max: number;
+            }>;
+            eligibility: {
+                protocol: "context.indexer.selector/v1";
+                expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+            };
+            artifact_kinds: {
+                required: string[];
+                discretionary: string[];
+            };
+        }[] | undefined;
+        question_target_domains?: {
+            id: string;
+            selector: {
+                operator: string;
+                parameters?: Record<string, import("./indexerRegistry.js").IndexerJson> | undefined;
+            };
+            grouping_operator: string;
+            subject_key_kind: string;
+            granularity: "module" | "identity";
+        }[] | undefined;
+        reader_question_contracts?: {
+            ref: string;
+            version: number;
+            semantic: string;
+            coverage_domain: string;
+            target_domain_ref: string;
+            target_selector: {
+                protocol: "context.indexer.selector/v1";
+                expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+            };
+            evidence_contract: {
+                accepted_kinds: ("contract" | "code" | "configuration" | "documentation" | "runbook" | "decision-record" | "test-result" | "runtime-observation" | "tool-snapshot")[];
+                minimum_items: number;
+                minimum_distinct_sources: number;
+                provenance_constraints?: {
+                    protocol: "context.indexer.selector/v1";
+                    expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+                } | undefined;
+            };
+            allowed_exclusion_reason_codes?: string[] | undefined;
+        }[] | undefined;
+    }, {
+        metrics?: ({
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "explicit";
+            direction: "minimum";
+            recommended_min: number;
+            hard_min: number;
+        } | {
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "explicit";
+            direction: "maximum";
+            recommended_max: number;
+            hard_max: number;
+        } | {
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "inflation-sensitive";
+            direction: "maximum";
+        })[] | undefined;
+        inventory_domains?: {
+            id: string;
+            selector: {
+                operator: string;
+                parameters?: Record<string, import("./indexerRegistry.js").IndexerJson> | undefined;
+            };
+            disposition_required: true;
+        }[] | undefined;
+        required_dispositions?: string[] | undefined;
+        artifact_policy_variants?: {
+            id: string;
+            thresholds: Record<string, {
+                recommended_max: number;
+            }>;
+            eligibility: {
+                protocol: "context.indexer.selector/v1";
+                expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+            };
+            artifact_kinds: {
+                required: string[];
+                discretionary: string[];
+            };
+        }[] | undefined;
+        question_target_domains?: {
+            id: string;
+            selector: {
+                operator: string;
+                parameters?: Record<string, import("./indexerRegistry.js").IndexerJson> | undefined;
+            };
+            grouping_operator: string;
+            subject_key_kind: string;
+            granularity: "module" | "identity";
+        }[] | undefined;
+        reader_question_contracts?: {
+            ref: string;
+            version: number;
+            semantic: string;
+            coverage_domain: string;
+            target_domain_ref: string;
+            target_selector: {
+                protocol: "context.indexer.selector/v1";
+                expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+            };
+            evidence_contract: {
+                accepted_kinds: ("contract" | "code" | "configuration" | "documentation" | "runbook" | "decision-record" | "test-result" | "runtime-observation" | "tool-snapshot")[];
+                minimum_items: number;
+                minimum_distinct_sources: number;
+                provenance_constraints?: {
+                    protocol: "context.indexer.selector/v1";
+                    expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+                } | undefined;
+            };
+            allowed_exclusion_reason_codes?: string[] | undefined;
+        }[] | undefined;
+    }>;
+    metric_tightenings: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+        metric_ref: z.ZodEffects<z.ZodString, string, string>;
+        direction: z.ZodLiteral<"minimum">;
+        recommended_min: z.ZodOptional<z.ZodNumber>;
+        hard_min: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        direction: "minimum";
+        metric_ref: string;
+        recommended_min?: number | undefined;
+        hard_min?: number | undefined;
+    }, {
+        direction: "minimum";
+        metric_ref: string;
+        recommended_min?: number | undefined;
+        hard_min?: number | undefined;
+    }>, {
+        direction: "minimum";
+        metric_ref: string;
+        recommended_min?: number | undefined;
+        hard_min?: number | undefined;
+    }, {
+        direction: "minimum";
+        metric_ref: string;
+        recommended_min?: number | undefined;
+        hard_min?: number | undefined;
+    }>, z.ZodEffects<z.ZodObject<{
+        metric_ref: z.ZodEffects<z.ZodString, string, string>;
+        direction: z.ZodLiteral<"maximum">;
+        recommended_max: z.ZodOptional<z.ZodNumber>;
+        hard_max: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        direction: "maximum";
+        metric_ref: string;
+        recommended_max?: number | undefined;
+        hard_max?: number | undefined;
+    }, {
+        direction: "maximum";
+        metric_ref: string;
+        recommended_max?: number | undefined;
+        hard_max?: number | undefined;
+    }>, {
+        direction: "maximum";
+        metric_ref: string;
+        recommended_max?: number | undefined;
+        hard_max?: number | undefined;
+    }, {
+        direction: "maximum";
+        metric_ref: string;
+        recommended_max?: number | undefined;
+        hard_max?: number | undefined;
+    }>]>, "many">>;
+    artifact_policy_threshold_tightenings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        variant_ref: z.ZodEffects<z.ZodString, string, string>;
+        metric_ref: z.ZodEffects<z.ZodString, string, string>;
+        recommended_max: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        recommended_max: number;
+        metric_ref: string;
+        variant_ref: string;
+    }, {
+        recommended_max: number;
+        metric_ref: string;
+        variant_ref: string;
+    }>, "many">>;
+    overlay_digest: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    protocol: "context.indexer.contract-overlay/v1";
+    version: string;
+    operator_contract_version: string;
+    operator_contract_digest: string;
+    extends: {
+        contract_digest: string;
+        version: string;
+        profile: string;
+    };
+    additions: {
+        metrics?: ({
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "explicit";
+            direction: "minimum";
+            recommended_min: number;
+            hard_min: number;
+        } | {
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "explicit";
+            direction: "maximum";
+            recommended_max: number;
+            hard_max: number;
+        } | {
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "inflation-sensitive";
+            direction: "maximum";
+        })[] | undefined;
+        inventory_domains?: {
+            id: string;
+            selector: {
+                operator: string;
+                parameters?: Record<string, import("./indexerRegistry.js").IndexerJson> | undefined;
+            };
+            disposition_required: true;
+        }[] | undefined;
+        required_dispositions?: string[] | undefined;
+        artifact_policy_variants?: {
+            id: string;
+            thresholds: Record<string, {
+                recommended_max: number;
+            }>;
+            eligibility: {
+                protocol: "context.indexer.selector/v1";
+                expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+            };
+            artifact_kinds: {
+                required: string[];
+                discretionary: string[];
+            };
+        }[] | undefined;
+        question_target_domains?: {
+            id: string;
+            selector: {
+                operator: string;
+                parameters?: Record<string, import("./indexerRegistry.js").IndexerJson> | undefined;
+            };
+            grouping_operator: string;
+            subject_key_kind: string;
+            granularity: "module" | "identity";
+        }[] | undefined;
+        reader_question_contracts?: {
+            ref: string;
+            version: number;
+            semantic: string;
+            coverage_domain: string;
+            target_domain_ref: string;
+            target_selector: {
+                protocol: "context.indexer.selector/v1";
+                expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+            };
+            evidence_contract: {
+                accepted_kinds: ("contract" | "code" | "configuration" | "documentation" | "runbook" | "decision-record" | "test-result" | "runtime-observation" | "tool-snapshot")[];
+                minimum_items: number;
+                minimum_distinct_sources: number;
+                provenance_constraints?: {
+                    protocol: "context.indexer.selector/v1";
+                    expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+                } | undefined;
+            };
+            allowed_exclusion_reason_codes?: string[] | undefined;
+        }[] | undefined;
+    };
+    overlay_digest: string;
+    metric_tightenings?: ({
+        direction: "minimum";
+        metric_ref: string;
+        recommended_min?: number | undefined;
+        hard_min?: number | undefined;
+    } | {
+        direction: "maximum";
+        metric_ref: string;
+        recommended_max?: number | undefined;
+        hard_max?: number | undefined;
+    })[] | undefined;
+    artifact_policy_threshold_tightenings?: {
+        recommended_max: number;
+        metric_ref: string;
+        variant_ref: string;
+    }[] | undefined;
+}, {
+    id: string;
+    protocol: "context.indexer.contract-overlay/v1";
+    version: string;
+    operator_contract_version: string;
+    operator_contract_digest: string;
+    extends: {
+        contract_digest: string;
+        version: string;
+        profile: string;
+    };
+    additions: {
+        metrics?: ({
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "explicit";
+            direction: "minimum";
+            recommended_min: number;
+            hard_min: number;
+        } | {
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "explicit";
+            direction: "maximum";
+            recommended_max: number;
+            hard_max: number;
+        } | {
+            id: string;
+            operator: string;
+            unit: "count" | "ratio";
+            threshold_policy: "inflation-sensitive";
+            direction: "maximum";
+        })[] | undefined;
+        inventory_domains?: {
+            id: string;
+            selector: {
+                operator: string;
+                parameters?: Record<string, import("./indexerRegistry.js").IndexerJson> | undefined;
+            };
+            disposition_required: true;
+        }[] | undefined;
+        required_dispositions?: string[] | undefined;
+        artifact_policy_variants?: {
+            id: string;
+            thresholds: Record<string, {
+                recommended_max: number;
+            }>;
+            eligibility: {
+                protocol: "context.indexer.selector/v1";
+                expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+            };
+            artifact_kinds: {
+                required: string[];
+                discretionary: string[];
+            };
+        }[] | undefined;
+        question_target_domains?: {
+            id: string;
+            selector: {
+                operator: string;
+                parameters?: Record<string, import("./indexerRegistry.js").IndexerJson> | undefined;
+            };
+            grouping_operator: string;
+            subject_key_kind: string;
+            granularity: "module" | "identity";
+        }[] | undefined;
+        reader_question_contracts?: {
+            ref: string;
+            version: number;
+            semantic: string;
+            coverage_domain: string;
+            target_domain_ref: string;
+            target_selector: {
+                protocol: "context.indexer.selector/v1";
+                expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+            };
+            evidence_contract: {
+                accepted_kinds: ("contract" | "code" | "configuration" | "documentation" | "runbook" | "decision-record" | "test-result" | "runtime-observation" | "tool-snapshot")[];
+                minimum_items: number;
+                minimum_distinct_sources: number;
+                provenance_constraints?: {
+                    protocol: "context.indexer.selector/v1";
+                    expression: import("./indexerRestrictedSelector.js").IndexerRestrictedSelectorExpression;
+                } | undefined;
+            };
+            allowed_exclusion_reason_codes?: string[] | undefined;
+        }[] | undefined;
+    };
+    overlay_digest: string;
+    metric_tightenings?: ({
+        direction: "minimum";
+        metric_ref: string;
+        recommended_min?: number | undefined;
+        hard_min?: number | undefined;
+    } | {
+        direction: "maximum";
+        metric_ref: string;
+        recommended_max?: number | undefined;
+        hard_max?: number | undefined;
+    })[] | undefined;
+    artifact_policy_threshold_tightenings?: {
+        recommended_max: number;
+        metric_ref: string;
+        variant_ref: string;
+    }[] | undefined;
+}>;
+export type IndexerContractOverlay = z.infer<typeof indexerContractOverlaySchema>;
+export declare function indexerContractOverlayDigest(overlay: Omit<IndexerContractOverlay, "overlay_digest">): string;
+export interface IndexerOverlayConformanceReport {
+    protocol: "context.indexer.overlay-conformance-report/v1";
+    overlay_digest: string;
+    base_contract_digest: string;
+    operator_contract_digest: string;
+    monotonic: true;
+    added_refs: string[];
+    tightened_metric_refs: string[];
+    tightened_artifact_policy_refs: string[];
+    report_digest: string;
+}
+export declare function validateIndexerContractOverlay(input: {
+    overlay: unknown;
+    baseContract: unknown;
+    operatorContract: unknown;
+}): {
+    overlay: IndexerContractOverlay;
+    effectiveProfile: IndexerProfileContractEntry;
+    report: IndexerOverlayConformanceReport;
+};
+export declare const indexerOverlayAttestationSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"context.indexer.overlay-attestation/v1">;
+    overlay: z.ZodObject<{
+        protocol: z.ZodLiteral<"context.indexer.contract-overlay/v1">;
+        id: z.ZodEffects<z.ZodString, string, string>;
+        version: z.ZodString;
+        digest: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        protocol: "context.indexer.contract-overlay/v1";
+        digest: string;
+        version: string;
+    }, {
+        id: string;
+        protocol: "context.indexer.contract-overlay/v1";
+        digest: string;
+        version: string;
+    }>;
+    base: z.ZodObject<{
+        profile: z.ZodEffects<z.ZodString, string, string>;
+        version: z.ZodString;
+        contract_digest: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        contract_digest: string;
+        version: string;
+        profile: string;
+    }, {
+        contract_digest: string;
+        version: string;
+        profile: string;
+    }>;
+    operator_contract: z.ZodObject<{
+        version: z.ZodString;
+        digest: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        digest: string;
+        version: string;
+    }, {
+        digest: string;
+        version: string;
+    }>;
+    issuer: z.ZodEffects<z.ZodString, string, string>;
+    key_id: z.ZodEffects<z.ZodString, string, string>;
+    algorithm: z.ZodLiteral<"ed25519">;
+    signature: z.ZodString;
+    attestation_digest: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    protocol: "context.indexer.overlay-attestation/v1";
+    issuer: string;
+    overlay: {
+        id: string;
+        protocol: "context.indexer.contract-overlay/v1";
+        digest: string;
+        version: string;
+    };
+    base: {
+        contract_digest: string;
+        version: string;
+        profile: string;
+    };
+    operator_contract: {
+        digest: string;
+        version: string;
+    };
+    key_id: string;
+    algorithm: "ed25519";
+    signature: string;
+    attestation_digest: string;
+}, {
+    protocol: "context.indexer.overlay-attestation/v1";
+    issuer: string;
+    overlay: {
+        id: string;
+        protocol: "context.indexer.contract-overlay/v1";
+        digest: string;
+        version: string;
+    };
+    base: {
+        contract_digest: string;
+        version: string;
+        profile: string;
+    };
+    operator_contract: {
+        digest: string;
+        version: string;
+    };
+    key_id: string;
+    algorithm: "ed25519";
+    signature: string;
+    attestation_digest: string;
+}>;
+export type IndexerOverlayAttestation = z.infer<typeof indexerOverlayAttestationSchema>;
+export declare function indexerOverlayAttestationSigningPayload(attestation: Omit<IndexerOverlayAttestation, "signature" | "attestation_digest">): string;
+export declare function indexerOverlayAttestationDigest(attestation: Omit<IndexerOverlayAttestation, "attestation_digest">): string;
+export declare const indexerOverlayTrustBundleSchema: z.ZodEffects<z.ZodObject<{
+    protocol: z.ZodLiteral<"context.indexer.overlay-trust-bundle/v1">;
+    policy_id: z.ZodEffects<z.ZodString, string, string>;
+    policy_version: z.ZodString;
+    issuers: z.ZodArray<z.ZodObject<{
+        id: z.ZodEffects<z.ZodString, string, string>;
+        keys: z.ZodArray<z.ZodObject<{
+            key_id: z.ZodEffects<z.ZodString, string, string>;
+            algorithm: z.ZodLiteral<"ed25519">;
+            public_key: z.ZodString;
+            not_before: z.ZodString;
+            not_after: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            key_id: string;
+            algorithm: "ed25519";
+            public_key: string;
+            not_before: string;
+            not_after: string;
+        }, {
+            key_id: string;
+            algorithm: "ed25519";
+            public_key: string;
+            not_before: string;
+            not_after: string;
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        keys: {
+            key_id: string;
+            algorithm: "ed25519";
+            public_key: string;
+            not_before: string;
+            not_after: string;
+        }[];
+        id: string;
+    }, {
+        keys: {
+            key_id: string;
+            algorithm: "ed25519";
+            public_key: string;
+            not_before: string;
+            not_after: string;
+        }[];
+        id: string;
+    }>, "many">;
+    revocations: z.ZodArray<z.ZodObject<{
+        issuer: z.ZodEffects<z.ZodString, string, string>;
+        key_id: z.ZodEffects<z.ZodString, string, string>;
+        revoked_at: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        issuer: string;
+        key_id: string;
+        revoked_at: string;
+    }, {
+        issuer: string;
+        key_id: string;
+        revoked_at: string;
+    }>, "many">;
+    policy_digest: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    protocol: "context.indexer.overlay-trust-bundle/v1";
+    policy_digest: string;
+    policy_id: string;
+    policy_version: string;
+    issuers: {
+        keys: {
+            key_id: string;
+            algorithm: "ed25519";
+            public_key: string;
+            not_before: string;
+            not_after: string;
+        }[];
+        id: string;
+    }[];
+    revocations: {
+        issuer: string;
+        key_id: string;
+        revoked_at: string;
+    }[];
+}, {
+    protocol: "context.indexer.overlay-trust-bundle/v1";
+    policy_digest: string;
+    policy_id: string;
+    policy_version: string;
+    issuers: {
+        keys: {
+            key_id: string;
+            algorithm: "ed25519";
+            public_key: string;
+            not_before: string;
+            not_after: string;
+        }[];
+        id: string;
+    }[];
+    revocations: {
+        issuer: string;
+        key_id: string;
+        revoked_at: string;
+    }[];
+}>, {
+    protocol: "context.indexer.overlay-trust-bundle/v1";
+    policy_digest: string;
+    policy_id: string;
+    policy_version: string;
+    issuers: {
+        keys: {
+            key_id: string;
+            algorithm: "ed25519";
+            public_key: string;
+            not_before: string;
+            not_after: string;
+        }[];
+        id: string;
+    }[];
+    revocations: {
+        issuer: string;
+        key_id: string;
+        revoked_at: string;
+    }[];
+}, {
+    protocol: "context.indexer.overlay-trust-bundle/v1";
+    policy_digest: string;
+    policy_id: string;
+    policy_version: string;
+    issuers: {
+        keys: {
+            key_id: string;
+            algorithm: "ed25519";
+            public_key: string;
+            not_before: string;
+            not_after: string;
+        }[];
+        id: string;
+    }[];
+    revocations: {
+        issuer: string;
+        key_id: string;
+        revoked_at: string;
+    }[];
+}>;
+export type IndexerOverlayTrustBundle = z.infer<typeof indexerOverlayTrustBundleSchema>;
+export declare function indexerOverlayTrustBundleDigest(bundle: Omit<IndexerOverlayTrustBundle, "policy_digest">): string;
+export declare const indexerOverlayTrustBundleEnvelopeSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"context.indexer.overlay-trust-bundle-envelope/v1">;
+    adapter: z.ZodEffects<z.ZodString, string, string>;
+    adapter_version: z.ZodString;
+    management_authority_digest: z.ZodString;
+    bundle: z.ZodEffects<z.ZodObject<{
+        protocol: z.ZodLiteral<"context.indexer.overlay-trust-bundle/v1">;
+        policy_id: z.ZodEffects<z.ZodString, string, string>;
+        policy_version: z.ZodString;
+        issuers: z.ZodArray<z.ZodObject<{
+            id: z.ZodEffects<z.ZodString, string, string>;
+            keys: z.ZodArray<z.ZodObject<{
+                key_id: z.ZodEffects<z.ZodString, string, string>;
+                algorithm: z.ZodLiteral<"ed25519">;
+                public_key: z.ZodString;
+                not_before: z.ZodString;
+                not_after: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                key_id: string;
+                algorithm: "ed25519";
+                public_key: string;
+                not_before: string;
+                not_after: string;
+            }, {
+                key_id: string;
+                algorithm: "ed25519";
+                public_key: string;
+                not_before: string;
+                not_after: string;
+            }>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            keys: {
+                key_id: string;
+                algorithm: "ed25519";
+                public_key: string;
+                not_before: string;
+                not_after: string;
+            }[];
+            id: string;
+        }, {
+            keys: {
+                key_id: string;
+                algorithm: "ed25519";
+                public_key: string;
+                not_before: string;
+                not_after: string;
+            }[];
+            id: string;
+        }>, "many">;
+        revocations: z.ZodArray<z.ZodObject<{
+            issuer: z.ZodEffects<z.ZodString, string, string>;
+            key_id: z.ZodEffects<z.ZodString, string, string>;
+            revoked_at: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            issuer: string;
+            key_id: string;
+            revoked_at: string;
+        }, {
+            issuer: string;
+            key_id: string;
+            revoked_at: string;
+        }>, "many">;
+        policy_digest: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        protocol: "context.indexer.overlay-trust-bundle/v1";
+        policy_digest: string;
+        policy_id: string;
+        policy_version: string;
+        issuers: {
+            keys: {
+                key_id: string;
+                algorithm: "ed25519";
+                public_key: string;
+                not_before: string;
+                not_after: string;
+            }[];
+            id: string;
+        }[];
+        revocations: {
+            issuer: string;
+            key_id: string;
+            revoked_at: string;
+        }[];
+    }, {
+        protocol: "context.indexer.overlay-trust-bundle/v1";
+        policy_digest: string;
+        policy_id: string;
+        policy_version: string;
+        issuers: {
+            keys: {
+                key_id: string;
+                algorithm: "ed25519";
+                public_key: string;
+                not_before: string;
+                not_after: string;
+            }[];
+            id: string;
+        }[];
+        revocations: {
+            issuer: string;
+            key_id: string;
+            revoked_at: string;
+        }[];
+    }>, {
+        protocol: "context.indexer.overlay-trust-bundle/v1";
+        policy_digest: string;
+        policy_id: string;
+        policy_version: string;
+        issuers: {
+            keys: {
+                key_id: string;
+                algorithm: "ed25519";
+                public_key: string;
+                not_before: string;
+                not_after: string;
+            }[];
+            id: string;
+        }[];
+        revocations: {
+            issuer: string;
+            key_id: string;
+            revoked_at: string;
+        }[];
+    }, {
+        protocol: "context.indexer.overlay-trust-bundle/v1";
+        policy_digest: string;
+        policy_id: string;
+        policy_version: string;
+        issuers: {
+            keys: {
+                key_id: string;
+                algorithm: "ed25519";
+                public_key: string;
+                not_before: string;
+                not_after: string;
+            }[];
+            id: string;
+        }[];
+        revocations: {
+            issuer: string;
+            key_id: string;
+            revoked_at: string;
+        }[];
+    }>;
+}, "strict", z.ZodTypeAny, {
+    adapter: string;
+    protocol: "context.indexer.overlay-trust-bundle-envelope/v1";
+    bundle: {
+        protocol: "context.indexer.overlay-trust-bundle/v1";
+        policy_digest: string;
+        policy_id: string;
+        policy_version: string;
+        issuers: {
+            keys: {
+                key_id: string;
+                algorithm: "ed25519";
+                public_key: string;
+                not_before: string;
+                not_after: string;
+            }[];
+            id: string;
+        }[];
+        revocations: {
+            issuer: string;
+            key_id: string;
+            revoked_at: string;
+        }[];
+    };
+    adapter_version: string;
+    management_authority_digest: string;
+}, {
+    adapter: string;
+    protocol: "context.indexer.overlay-trust-bundle-envelope/v1";
+    bundle: {
+        protocol: "context.indexer.overlay-trust-bundle/v1";
+        policy_digest: string;
+        policy_id: string;
+        policy_version: string;
+        issuers: {
+            keys: {
+                key_id: string;
+                algorithm: "ed25519";
+                public_key: string;
+                not_before: string;
+                not_after: string;
+            }[];
+            id: string;
+        }[];
+        revocations: {
+            issuer: string;
+            key_id: string;
+            revoked_at: string;
+        }[];
+    };
+    adapter_version: string;
+    management_authority_digest: string;
+}>;
+export type IndexerOverlayTrustBundleEnvelope = z.infer<typeof indexerOverlayTrustBundleEnvelopeSchema>;
+export declare const indexerOverlayTrustReceiptSchema: z.ZodDiscriminatedUnion<"trust_class", [z.ZodObject<{
+    protocol: z.ZodLiteral<"context.indexer.overlay-trust-receipt/v1">;
+    trust_class: z.ZodLiteral<"enterprise-signed">;
+    project_ref: z.ZodNull;
+    overlay_digest: z.ZodString;
+    attestation_digest: z.ZodString;
+    base_contract_digest: z.ZodString;
+    provider_integrity: z.ZodString;
+    operator_contract_digest: z.ZodString;
+    conformance_report_digest: z.ZodString;
+    trust_adapter: z.ZodEffects<z.ZodString, string, string>;
+    trust_adapter_version: z.ZodString;
+    trust_management_authority_digest: z.ZodString;
+    trust_policy_digest: z.ZodString;
+    authorization_receipt_digest: z.ZodNull;
+    receipt_digest: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    protocol: "context.indexer.overlay-trust-receipt/v1";
+    receipt_digest: string;
+    operator_contract_digest: string;
+    project_ref: null;
+    provider_integrity: string;
+    authorization_receipt_digest: null;
+    overlay_digest: string;
+    base_contract_digest: string;
+    attestation_digest: string;
+    trust_class: "enterprise-signed";
+    conformance_report_digest: string;
+    trust_adapter: string;
+    trust_adapter_version: string;
+    trust_management_authority_digest: string;
+    trust_policy_digest: string;
+}, {
+    protocol: "context.indexer.overlay-trust-receipt/v1";
+    receipt_digest: string;
+    operator_contract_digest: string;
+    project_ref: null;
+    provider_integrity: string;
+    authorization_receipt_digest: null;
+    overlay_digest: string;
+    base_contract_digest: string;
+    attestation_digest: string;
+    trust_class: "enterprise-signed";
+    conformance_report_digest: string;
+    trust_adapter: string;
+    trust_adapter_version: string;
+    trust_management_authority_digest: string;
+    trust_policy_digest: string;
+}>, z.ZodObject<{
+    protocol: z.ZodLiteral<"context.indexer.overlay-trust-receipt/v1">;
+    trust_class: z.ZodLiteral<"project-authorized-exact-digest">;
+    project_ref: z.ZodString;
+    overlay_digest: z.ZodString;
+    attestation_digest: z.ZodNullable<z.ZodString>;
+    base_contract_digest: z.ZodString;
+    provider_integrity: z.ZodString;
+    operator_contract_digest: z.ZodString;
+    conformance_report_digest: z.ZodString;
+    trust_adapter: z.ZodNull;
+    trust_adapter_version: z.ZodNull;
+    trust_management_authority_digest: z.ZodNull;
+    trust_policy_digest: z.ZodNull;
+    authorization_receipt_digest: z.ZodString;
+    receipt_digest: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    protocol: "context.indexer.overlay-trust-receipt/v1";
+    receipt_digest: string;
+    operator_contract_digest: string;
+    project_ref: string;
+    provider_integrity: string;
+    authorization_receipt_digest: string;
+    overlay_digest: string;
+    base_contract_digest: string;
+    attestation_digest: string | null;
+    trust_class: "project-authorized-exact-digest";
+    conformance_report_digest: string;
+    trust_adapter: null;
+    trust_adapter_version: null;
+    trust_management_authority_digest: null;
+    trust_policy_digest: null;
+}, {
+    protocol: "context.indexer.overlay-trust-receipt/v1";
+    receipt_digest: string;
+    operator_contract_digest: string;
+    project_ref: string;
+    provider_integrity: string;
+    authorization_receipt_digest: string;
+    overlay_digest: string;
+    base_contract_digest: string;
+    attestation_digest: string | null;
+    trust_class: "project-authorized-exact-digest";
+    conformance_report_digest: string;
+    trust_adapter: null;
+    trust_adapter_version: null;
+    trust_management_authority_digest: null;
+    trust_policy_digest: null;
+}>]>;
+export type IndexerOverlayTrustReceipt = z.infer<typeof indexerOverlayTrustReceiptSchema>;
+export declare function indexerOverlayTrustReceiptDigest(receipt: Omit<IndexerOverlayTrustReceipt, "receipt_digest">): string;
+export declare function validateIndexerOverlayAttestation(value: unknown, overlay: IndexerContractOverlay, base: IndexerProfileContract, operators: IndexerOperatorContract): IndexerOverlayAttestation;
+export declare function validateIndexerOverlayTrustBundleEnvelope(value: unknown): IndexerOverlayTrustBundleEnvelope;
+export declare function verifyEnterpriseIndexerOverlayTrust(input: {
+    overlayValidation: ReturnType<typeof validateIndexerContractOverlay>;
+    baseContract: IndexerProfileContract;
+    operatorContract: IndexerOperatorContract;
+    providerIntegrity: string;
+    attestation: unknown;
+    trustBundleEnvelope: unknown;
+    now?: Date;
+}): IndexerOverlayTrustReceipt;
+export declare const indexerOverlayProjectAuthorizationSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"context.indexer.overlay-project-authorization/v1">;
+    project_ref: z.ZodString;
+    overlay_digest: z.ZodString;
+    attestation_digest: z.ZodNullable<z.ZodString>;
+    base_contract_digest: z.ZodString;
+    provider_integrity: z.ZodString;
+    operator_contract_digest: z.ZodString;
+    conformance_report_digest: z.ZodString;
+    authority_ref: z.ZodString;
+    authority_scope_digest: z.ZodString;
+    authorization_receipt_digest: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    protocol: "context.indexer.overlay-project-authorization/v1";
+    authority_ref: string;
+    operator_contract_digest: string;
+    project_ref: string;
+    provider_integrity: string;
+    authority_scope_digest: string;
+    authorization_receipt_digest: string;
+    overlay_digest: string;
+    base_contract_digest: string;
+    attestation_digest: string | null;
+    conformance_report_digest: string;
+}, {
+    protocol: "context.indexer.overlay-project-authorization/v1";
+    authority_ref: string;
+    operator_contract_digest: string;
+    project_ref: string;
+    provider_integrity: string;
+    authority_scope_digest: string;
+    authorization_receipt_digest: string;
+    overlay_digest: string;
+    base_contract_digest: string;
+    attestation_digest: string | null;
+    conformance_report_digest: string;
+}>;
+export type IndexerOverlayProjectAuthorization = z.infer<typeof indexerOverlayProjectAuthorizationSchema>;
+export declare function indexerOverlayProjectAuthorizationDigest(authorization: Omit<IndexerOverlayProjectAuthorization, "authorization_receipt_digest">): string;
+export declare function authorizeProjectIndexerOverlay(input: {
+    overlayValidation: ReturnType<typeof validateIndexerContractOverlay>;
+    baseContract: IndexerProfileContract;
+    operatorContract: IndexerOperatorContract;
+    providerIntegrity: string;
+    projectRef: string;
+    declaredAttestationDigest: string | null;
+    authorization: unknown;
+}): IndexerOverlayTrustReceipt;