@kya-os/cli 1.8.3 → 2.0.2

package/node_modules/@kya-os/contracts/dist/reputation/credentials.d.ts

@@ -0,0 +1,1493 @@
+/**
+ * Reputation Credential Schemas
+ *
+ * W3C Verifiable Credential schemas for reputation attestations.
+ * These credentials allow reputation scores to be cryptographically signed
+ * and verified as portable, tamper-proof attestations.
+ *
+ * Credential Types:
+ * - ReputationCredential: Attests to an agent's reputation score at a point in time
+ * - ReputationAttestation: Lighter-weight attestation for specific contexts
+ *
+ * Related Spec: MCP-I §3.1 (VC Structure), §5.3 (Reputation Credentials)
+ * W3C Reference: Verifiable Credentials Data Model 1.1
+ */
+import { z } from "zod";
+import { CredentialStatusSchema } from "../vc/schemas.js";
+import { type ReputationScore } from "./schemas.js";
+/**
+ * Reputation Credential JSON-LD Context
+ */
+export declare const REPUTATION_CREDENTIAL_CONTEXT: "https://schema.modelcontextprotocol-identity.io/xmcp-i/credentials/reputation.v1.0.0.json";
+/**
+ * Reputation Credential Type
+ */
+export declare const REPUTATION_CREDENTIAL_TYPE: "ReputationCredential";
+/**
+ * Reputation Attestation Type
+ */
+export declare const REPUTATION_ATTESTATION_TYPE: "ReputationAttestation";
+/**
+ * Reputation Credential Subject Schema
+ *
+ * The credentialSubject of a ReputationCredential contains:
+ * - id: The agent DID being attested
+ * - reputation: The complete reputation score at time of issuance
+ */
+export declare const ReputationCredentialSubjectSchema: z.ZodObject<{
+    /** Subject DID (the agent whose reputation is being attested) */
+    id: z.ZodEffects<z.ZodString, string, string>;
+    /** The reputation score being attested */
+    reputation: z.ZodObject<{
+        /** Final reputation score (0-100) */
+        score: z.ZodNumber;
+        /** Confidence in the score (0-1) */
+        confidence: z.ZodNumber;
+        /** Human-readable confidence level */
+        confidenceLevel: z.ZodEnum<["Low", "Medium", "High", "VeryHigh"]>;
+        /** Human-readable reputation level */
+        level: z.ZodEnum<["Unknown", "Poor", "BelowAverage", "Average", "Good", "Excellent", "Outstanding"]>;
+        /** Whether this is a provisional score */
+        isProvisional: z.ZodBoolean;
+        /** Timestamp when the score was calculated (ISO 8601) */
+        calculatedAt: z.ZodString;
+        /** Optional score components (for transparency) */
+        components: z.ZodOptional<z.ZodObject<{
+            priorScore: z.ZodNumber;
+            empiricalScore: z.ZodNumber;
+            confidenceWeight: z.ZodNumber;
+            priorWeight: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            priorScore: number;
+            empiricalScore: number;
+            confidenceWeight: number;
+            priorWeight: number;
+        }, {
+            priorScore: number;
+            empiricalScore: number;
+            confidenceWeight: number;
+            priorWeight: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        confidence: number;
+        score: number;
+        confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+        level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+        isProvisional: boolean;
+        calculatedAt: string;
+        components?: {
+            priorScore: number;
+            empiricalScore: number;
+            confidenceWeight: number;
+            priorWeight: number;
+        } | undefined;
+    }, {
+        confidence: number;
+        score: number;
+        confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+        level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+        isProvisional: boolean;
+        calculatedAt: string;
+        components?: {
+            priorScore: number;
+            empiricalScore: number;
+            confidenceWeight: number;
+            priorWeight: number;
+        } | undefined;
+    }>;
+    /** Context in which this reputation applies */
+    context: z.ZodOptional<z.ZodObject<{
+        /** Scope of the reputation (e.g., 'global', 'domain-specific') */
+        scope: z.ZodDefault<z.ZodString>;
+        /** Domain or category (e.g., 'e-commerce', 'healthcare') */
+        domain: z.ZodOptional<z.ZodString>;
+        /** Geographic region (if applicable) */
+        region: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        scope: string;
+        region?: string | undefined;
+        domain?: string | undefined;
+    }, {
+        region?: string | undefined;
+        scope?: string | undefined;
+        domain?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    reputation: {
+        confidence: number;
+        score: number;
+        confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+        level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+        isProvisional: boolean;
+        calculatedAt: string;
+        components?: {
+            priorScore: number;
+            empiricalScore: number;
+            confidenceWeight: number;
+            priorWeight: number;
+        } | undefined;
+    };
+    context?: {
+        scope: string;
+        region?: string | undefined;
+        domain?: string | undefined;
+    } | undefined;
+}, {
+    id: string;
+    reputation: {
+        confidence: number;
+        score: number;
+        confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+        level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+        isProvisional: boolean;
+        calculatedAt: string;
+        components?: {
+            priorScore: number;
+            empiricalScore: number;
+            confidenceWeight: number;
+            priorWeight: number;
+        } | undefined;
+    };
+    context?: {
+        region?: string | undefined;
+        scope?: string | undefined;
+        domain?: string | undefined;
+    } | undefined;
+}>;
+export type ReputationCredentialSubject = z.infer<typeof ReputationCredentialSubjectSchema>;
+/**
+ * Reputation Credential Schema
+ *
+ * W3C Verifiable Credential for reputation attestation.
+ * This is the PRIMARY format for portable reputation scores.
+ *
+ * Structure:
+ * - @context: [...W3C VC contexts, reputation context]
+ * - type: ['VerifiableCredential', 'ReputationCredential']
+ * - issuer: Reputation authority DID (e.g., KYA platform)
+ * - issuanceDate: When the reputation was calculated
+ * - expirationDate: When this attestation expires
+ * - credentialSubject: Contains agent DID + reputation data
+ * - credentialStatus: StatusList2021Entry for revocation
+ * - proof: Ed25519Signature2020 or similar
+ */
+export declare const ReputationCredentialSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+} & {
+    "@context": z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">, (string | Record<string, any>)[], (string | Record<string, any>)[]>;
+    type: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+    issuer: z.ZodUnion<[z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>]>;
+    issuanceDate: z.ZodString;
+    expirationDate: z.ZodOptional<z.ZodString>;
+    credentialSubject: z.ZodObject<{
+        /** Subject DID (the agent whose reputation is being attested) */
+        id: z.ZodEffects<z.ZodString, string, string>;
+        /** The reputation score being attested */
+        reputation: z.ZodObject<{
+            /** Final reputation score (0-100) */
+            score: z.ZodNumber;
+            /** Confidence in the score (0-1) */
+            confidence: z.ZodNumber;
+            /** Human-readable confidence level */
+            confidenceLevel: z.ZodEnum<["Low", "Medium", "High", "VeryHigh"]>;
+            /** Human-readable reputation level */
+            level: z.ZodEnum<["Unknown", "Poor", "BelowAverage", "Average", "Good", "Excellent", "Outstanding"]>;
+            /** Whether this is a provisional score */
+            isProvisional: z.ZodBoolean;
+            /** Timestamp when the score was calculated (ISO 8601) */
+            calculatedAt: z.ZodString;
+            /** Optional score components (for transparency) */
+            components: z.ZodOptional<z.ZodObject<{
+                priorScore: z.ZodNumber;
+                empiricalScore: z.ZodNumber;
+                confidenceWeight: z.ZodNumber;
+                priorWeight: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            }, {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            confidence: number;
+            score: number;
+            confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+            level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+            isProvisional: boolean;
+            calculatedAt: string;
+            components?: {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            } | undefined;
+        }, {
+            confidence: number;
+            score: number;
+            confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+            level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+            isProvisional: boolean;
+            calculatedAt: string;
+            components?: {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            } | undefined;
+        }>;
+        /** Context in which this reputation applies */
+        context: z.ZodOptional<z.ZodObject<{
+            /** Scope of the reputation (e.g., 'global', 'domain-specific') */
+            scope: z.ZodDefault<z.ZodString>;
+            /** Domain or category (e.g., 'e-commerce', 'healthcare') */
+            domain: z.ZodOptional<z.ZodString>;
+            /** Geographic region (if applicable) */
+            region: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            scope: string;
+            region?: string | undefined;
+            domain?: string | undefined;
+        }, {
+            region?: string | undefined;
+            scope?: string | undefined;
+            domain?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        reputation: {
+            confidence: number;
+            score: number;
+            confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+            level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+            isProvisional: boolean;
+            calculatedAt: string;
+            components?: {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            } | undefined;
+        };
+        context?: {
+            scope: string;
+            region?: string | undefined;
+            domain?: string | undefined;
+        } | undefined;
+    }, {
+        id: string;
+        reputation: {
+            confidence: number;
+            score: number;
+            confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+            level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+            isProvisional: boolean;
+            calculatedAt: string;
+            components?: {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            } | undefined;
+        };
+        context?: {
+            region?: string | undefined;
+            scope?: string | undefined;
+            domain?: string | undefined;
+        } | undefined;
+    }>;
+    credentialStatus: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"StatusList2021Entry">;
+        statusPurpose: z.ZodEnum<["revocation", "suspension"]>;
+        statusListIndex: z.ZodString;
+        statusListCredential: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }>>;
+    proof: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    id: z.ZodOptional<z.ZodString>;
+} & {
+    "@context": z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">, (string | Record<string, any>)[], (string | Record<string, any>)[]>;
+    type: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+    issuer: z.ZodUnion<[z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>]>;
+    issuanceDate: z.ZodString;
+    expirationDate: z.ZodOptional<z.ZodString>;
+    credentialSubject: z.ZodObject<{
+        /** Subject DID (the agent whose reputation is being attested) */
+        id: z.ZodEffects<z.ZodString, string, string>;
+        /** The reputation score being attested */
+        reputation: z.ZodObject<{
+            /** Final reputation score (0-100) */
+            score: z.ZodNumber;
+            /** Confidence in the score (0-1) */
+            confidence: z.ZodNumber;
+            /** Human-readable confidence level */
+            confidenceLevel: z.ZodEnum<["Low", "Medium", "High", "VeryHigh"]>;
+            /** Human-readable reputation level */
+            level: z.ZodEnum<["Unknown", "Poor", "BelowAverage", "Average", "Good", "Excellent", "Outstanding"]>;
+            /** Whether this is a provisional score */
+            isProvisional: z.ZodBoolean;
+            /** Timestamp when the score was calculated (ISO 8601) */
+            calculatedAt: z.ZodString;
+            /** Optional score components (for transparency) */
+            components: z.ZodOptional<z.ZodObject<{
+                priorScore: z.ZodNumber;
+                empiricalScore: z.ZodNumber;
+                confidenceWeight: z.ZodNumber;
+                priorWeight: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            }, {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            confidence: number;
+            score: number;
+            confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+            level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+            isProvisional: boolean;
+            calculatedAt: string;
+            components?: {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            } | undefined;
+        }, {
+            confidence: number;
+            score: number;
+            confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+            level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+            isProvisional: boolean;
+            calculatedAt: string;
+            components?: {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            } | undefined;
+        }>;
+        /** Context in which this reputation applies */
+        context: z.ZodOptional<z.ZodObject<{
+            /** Scope of the reputation (e.g., 'global', 'domain-specific') */
+            scope: z.ZodDefault<z.ZodString>;
+            /** Domain or category (e.g., 'e-commerce', 'healthcare') */
+            domain: z.ZodOptional<z.ZodString>;
+            /** Geographic region (if applicable) */
+            region: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            scope: string;
+            region?: string | undefined;
+            domain?: string | undefined;
+        }, {
+            region?: string | undefined;
+            scope?: string | undefined;
+            domain?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        reputation: {
+            confidence: number;
+            score: number;
+            confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+            level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+            isProvisional: boolean;
+            calculatedAt: string;
+            components?: {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            } | undefined;
+        };
+        context?: {
+            scope: string;
+            region?: string | undefined;
+            domain?: string | undefined;
+        } | undefined;
+    }, {
+        id: string;
+        reputation: {
+            confidence: number;
+            score: number;
+            confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+            level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+            isProvisional: boolean;
+            calculatedAt: string;
+            components?: {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            } | undefined;
+        };
+        context?: {
+            region?: string | undefined;
+            scope?: string | undefined;
+            domain?: string | undefined;
+        } | undefined;
+    }>;
+    credentialStatus: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"StatusList2021Entry">;
+        statusPurpose: z.ZodEnum<["revocation", "suspension"]>;
+        statusListIndex: z.ZodString;
+        statusListCredential: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }>>;
+    proof: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    id: z.ZodOptional<z.ZodString>;
+} & {
+    "@context": z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">, (string | Record<string, any>)[], (string | Record<string, any>)[]>;
+    type: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+    issuer: z.ZodUnion<[z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>]>;
+    issuanceDate: z.ZodString;
+    expirationDate: z.ZodOptional<z.ZodString>;
+    credentialSubject: z.ZodObject<{
+        /** Subject DID (the agent whose reputation is being attested) */
+        id: z.ZodEffects<z.ZodString, string, string>;
+        /** The reputation score being attested */
+        reputation: z.ZodObject<{
+            /** Final reputation score (0-100) */
+            score: z.ZodNumber;
+            /** Confidence in the score (0-1) */
+            confidence: z.ZodNumber;
+            /** Human-readable confidence level */
+            confidenceLevel: z.ZodEnum<["Low", "Medium", "High", "VeryHigh"]>;
+            /** Human-readable reputation level */
+            level: z.ZodEnum<["Unknown", "Poor", "BelowAverage", "Average", "Good", "Excellent", "Outstanding"]>;
+            /** Whether this is a provisional score */
+            isProvisional: z.ZodBoolean;
+            /** Timestamp when the score was calculated (ISO 8601) */
+            calculatedAt: z.ZodString;
+            /** Optional score components (for transparency) */
+            components: z.ZodOptional<z.ZodObject<{
+                priorScore: z.ZodNumber;
+                empiricalScore: z.ZodNumber;
+                confidenceWeight: z.ZodNumber;
+                priorWeight: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            }, {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            confidence: number;
+            score: number;
+            confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+            level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+            isProvisional: boolean;
+            calculatedAt: string;
+            components?: {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            } | undefined;
+        }, {
+            confidence: number;
+            score: number;
+            confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+            level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+            isProvisional: boolean;
+            calculatedAt: string;
+            components?: {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            } | undefined;
+        }>;
+        /** Context in which this reputation applies */
+        context: z.ZodOptional<z.ZodObject<{
+            /** Scope of the reputation (e.g., 'global', 'domain-specific') */
+            scope: z.ZodDefault<z.ZodString>;
+            /** Domain or category (e.g., 'e-commerce', 'healthcare') */
+            domain: z.ZodOptional<z.ZodString>;
+            /** Geographic region (if applicable) */
+            region: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            scope: string;
+            region?: string | undefined;
+            domain?: string | undefined;
+        }, {
+            region?: string | undefined;
+            scope?: string | undefined;
+            domain?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        reputation: {
+            confidence: number;
+            score: number;
+            confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+            level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+            isProvisional: boolean;
+            calculatedAt: string;
+            components?: {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            } | undefined;
+        };
+        context?: {
+            scope: string;
+            region?: string | undefined;
+            domain?: string | undefined;
+        } | undefined;
+    }, {
+        id: string;
+        reputation: {
+            confidence: number;
+            score: number;
+            confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+            level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+            isProvisional: boolean;
+            calculatedAt: string;
+            components?: {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            } | undefined;
+        };
+        context?: {
+            region?: string | undefined;
+            scope?: string | undefined;
+            domain?: string | undefined;
+        } | undefined;
+    }>;
+    credentialStatus: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"StatusList2021Entry">;
+        statusPurpose: z.ZodEnum<["revocation", "suspension"]>;
+        statusListIndex: z.ZodString;
+        statusListCredential: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }>>;
+    proof: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type ReputationCredential = z.infer<typeof ReputationCredentialSchema>;
+/**
+ * Reputation Attestation Subject Schema
+ *
+ * Lighter-weight attestation for specific use cases.
+ * Contains only essential reputation information.
+ */
+export declare const ReputationAttestationSubjectSchema: z.ZodObject<{
+    /** Subject DID */
+    id: z.ZodString;
+    /** Reputation level (human-readable) */
+    level: z.ZodEnum<["Unknown", "Poor", "BelowAverage", "Average", "Good", "Excellent", "Outstanding"]>;
+    /** Numeric score (0-100) */
+    score: z.ZodNumber;
+    /** Whether the attestation issuer has high confidence */
+    highConfidence: z.ZodBoolean;
+    /** Specific capability or context being attested */
+    capability: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    score: number;
+    level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+    highConfidence: boolean;
+    capability?: string | undefined;
+}, {
+    id: string;
+    score: number;
+    level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+    highConfidence: boolean;
+    capability?: string | undefined;
+}>;
+export type ReputationAttestationSubject = z.infer<typeof ReputationAttestationSubjectSchema>;
+/**
+ * Reputation Attestation Schema
+ *
+ * Lightweight attestation for embedding in other contexts.
+ */
+export declare const ReputationAttestationSchema: z.ZodObject<{
+    '@context': z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>, "atleastone">, [string | Record<string, any>, ...(string | Record<string, any>)[]], [string | Record<string, any>, ...(string | Record<string, any>)[]]>;
+    id: z.ZodOptional<z.ZodString>;
+    issuer: z.ZodUnion<[z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>]>;
+    issuanceDate: z.ZodString;
+    expirationDate: z.ZodOptional<z.ZodString>;
+    credentialStatus: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"StatusList2021Entry">;
+        statusPurpose: z.ZodEnum<["revocation", "suspension"]>;
+        statusListIndex: z.ZodString;
+        statusListCredential: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }>>;
+    proof: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+} & {
+    type: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+    credentialSubject: z.ZodObject<{
+        /** Subject DID */
+        id: z.ZodString;
+        /** Reputation level (human-readable) */
+        level: z.ZodEnum<["Unknown", "Poor", "BelowAverage", "Average", "Good", "Excellent", "Outstanding"]>;
+        /** Numeric score (0-100) */
+        score: z.ZodNumber;
+        /** Whether the attestation issuer has high confidence */
+        highConfidence: z.ZodBoolean;
+        /** Specific capability or context being attested */
+        capability: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        score: number;
+        level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+        highConfidence: boolean;
+        capability?: string | undefined;
+    }, {
+        id: string;
+        score: number;
+        level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+        highConfidence: boolean;
+        capability?: string | undefined;
+    }>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    '@context': z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>, "atleastone">, [string | Record<string, any>, ...(string | Record<string, any>)[]], [string | Record<string, any>, ...(string | Record<string, any>)[]]>;
+    id: z.ZodOptional<z.ZodString>;
+    issuer: z.ZodUnion<[z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>]>;
+    issuanceDate: z.ZodString;
+    expirationDate: z.ZodOptional<z.ZodString>;
+    credentialStatus: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"StatusList2021Entry">;
+        statusPurpose: z.ZodEnum<["revocation", "suspension"]>;
+        statusListIndex: z.ZodString;
+        statusListCredential: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }>>;
+    proof: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+} & {
+    type: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+    credentialSubject: z.ZodObject<{
+        /** Subject DID */
+        id: z.ZodString;
+        /** Reputation level (human-readable) */
+        level: z.ZodEnum<["Unknown", "Poor", "BelowAverage", "Average", "Good", "Excellent", "Outstanding"]>;
+        /** Numeric score (0-100) */
+        score: z.ZodNumber;
+        /** Whether the attestation issuer has high confidence */
+        highConfidence: z.ZodBoolean;
+        /** Specific capability or context being attested */
+        capability: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        score: number;
+        level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+        highConfidence: boolean;
+        capability?: string | undefined;
+    }, {
+        id: string;
+        score: number;
+        level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+        highConfidence: boolean;
+        capability?: string | undefined;
+    }>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    '@context': z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>, "atleastone">, [string | Record<string, any>, ...(string | Record<string, any>)[]], [string | Record<string, any>, ...(string | Record<string, any>)[]]>;
+    id: z.ZodOptional<z.ZodString>;
+    issuer: z.ZodUnion<[z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>]>;
+    issuanceDate: z.ZodString;
+    expirationDate: z.ZodOptional<z.ZodString>;
+    credentialStatus: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"StatusList2021Entry">;
+        statusPurpose: z.ZodEnum<["revocation", "suspension"]>;
+        statusListIndex: z.ZodString;
+        statusListCredential: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }>>;
+    proof: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+} & {
+    type: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+    credentialSubject: z.ZodObject<{
+        /** Subject DID */
+        id: z.ZodString;
+        /** Reputation level (human-readable) */
+        level: z.ZodEnum<["Unknown", "Poor", "BelowAverage", "Average", "Good", "Excellent", "Outstanding"]>;
+        /** Numeric score (0-100) */
+        score: z.ZodNumber;
+        /** Whether the attestation issuer has high confidence */
+        highConfidence: z.ZodBoolean;
+        /** Specific capability or context being attested */
+        capability: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        score: number;
+        level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+        highConfidence: boolean;
+        capability?: string | undefined;
+    }, {
+        id: string;
+        score: number;
+        level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+        highConfidence: boolean;
+        capability?: string | undefined;
+    }>;
+}, z.ZodTypeAny, "passthrough">>;
+export type ReputationAttestation = z.infer<typeof ReputationAttestationSchema>;
+/**
+ * Validate a reputation credential
+ *
+ * @param credential - The credential to validate
+ * @returns Validation result
+ */
+export declare function validateReputationCredential(credential: unknown): z.SafeParseReturnType<z.objectInputType<{
+    id: z.ZodOptional<z.ZodString>;
+} & {
+    "@context": z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">, (string | Record<string, any>)[], (string | Record<string, any>)[]>;
+    type: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+    issuer: z.ZodUnion<[z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>]>;
+    issuanceDate: z.ZodString;
+    expirationDate: z.ZodOptional<z.ZodString>;
+    credentialSubject: z.ZodObject<{
+        /** Subject DID (the agent whose reputation is being attested) */
+        id: z.ZodEffects<z.ZodString, string, string>;
+        /** The reputation score being attested */
+        reputation: z.ZodObject<{
+            /** Final reputation score (0-100) */
+            score: z.ZodNumber;
+            /** Confidence in the score (0-1) */
+            confidence: z.ZodNumber;
+            /** Human-readable confidence level */
+            confidenceLevel: z.ZodEnum<["Low", "Medium", "High", "VeryHigh"]>;
+            /** Human-readable reputation level */
+            level: z.ZodEnum<["Unknown", "Poor", "BelowAverage", "Average", "Good", "Excellent", "Outstanding"]>;
+            /** Whether this is a provisional score */
+            isProvisional: z.ZodBoolean;
+            /** Timestamp when the score was calculated (ISO 8601) */
+            calculatedAt: z.ZodString;
+            /** Optional score components (for transparency) */
+            components: z.ZodOptional<z.ZodObject<{
+                priorScore: z.ZodNumber;
+                empiricalScore: z.ZodNumber;
+                confidenceWeight: z.ZodNumber;
+                priorWeight: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            }, {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            confidence: number;
+            score: number;
+            confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+            level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+            isProvisional: boolean;
+            calculatedAt: string;
+            components?: {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            } | undefined;
+        }, {
+            confidence: number;
+            score: number;
+            confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+            level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+            isProvisional: boolean;
+            calculatedAt: string;
+            components?: {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            } | undefined;
+        }>;
+        /** Context in which this reputation applies */
+        context: z.ZodOptional<z.ZodObject<{
+            /** Scope of the reputation (e.g., 'global', 'domain-specific') */
+            scope: z.ZodDefault<z.ZodString>;
+            /** Domain or category (e.g., 'e-commerce', 'healthcare') */
+            domain: z.ZodOptional<z.ZodString>;
+            /** Geographic region (if applicable) */
+            region: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            scope: string;
+            region?: string | undefined;
+            domain?: string | undefined;
+        }, {
+            region?: string | undefined;
+            scope?: string | undefined;
+            domain?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        reputation: {
+            confidence: number;
+            score: number;
+            confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+            level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+            isProvisional: boolean;
+            calculatedAt: string;
+            components?: {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            } | undefined;
+        };
+        context?: {
+            scope: string;
+            region?: string | undefined;
+            domain?: string | undefined;
+        } | undefined;
+    }, {
+        id: string;
+        reputation: {
+            confidence: number;
+            score: number;
+            confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+            level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+            isProvisional: boolean;
+            calculatedAt: string;
+            components?: {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            } | undefined;
+        };
+        context?: {
+            region?: string | undefined;
+            scope?: string | undefined;
+            domain?: string | undefined;
+        } | undefined;
+    }>;
+    credentialStatus: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"StatusList2021Entry">;
+        statusPurpose: z.ZodEnum<["revocation", "suspension"]>;
+        statusListIndex: z.ZodString;
+        statusListCredential: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }>>;
+    proof: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">, z.objectOutputType<{
+    id: z.ZodOptional<z.ZodString>;
+} & {
+    "@context": z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">, (string | Record<string, any>)[], (string | Record<string, any>)[]>;
+    type: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+    issuer: z.ZodUnion<[z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>]>;
+    issuanceDate: z.ZodString;
+    expirationDate: z.ZodOptional<z.ZodString>;
+    credentialSubject: z.ZodObject<{
+        /** Subject DID (the agent whose reputation is being attested) */
+        id: z.ZodEffects<z.ZodString, string, string>;
+        /** The reputation score being attested */
+        reputation: z.ZodObject<{
+            /** Final reputation score (0-100) */
+            score: z.ZodNumber;
+            /** Confidence in the score (0-1) */
+            confidence: z.ZodNumber;
+            /** Human-readable confidence level */
+            confidenceLevel: z.ZodEnum<["Low", "Medium", "High", "VeryHigh"]>;
+            /** Human-readable reputation level */
+            level: z.ZodEnum<["Unknown", "Poor", "BelowAverage", "Average", "Good", "Excellent", "Outstanding"]>;
+            /** Whether this is a provisional score */
+            isProvisional: z.ZodBoolean;
+            /** Timestamp when the score was calculated (ISO 8601) */
+            calculatedAt: z.ZodString;
+            /** Optional score components (for transparency) */
+            components: z.ZodOptional<z.ZodObject<{
+                priorScore: z.ZodNumber;
+                empiricalScore: z.ZodNumber;
+                confidenceWeight: z.ZodNumber;
+                priorWeight: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            }, {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            confidence: number;
+            score: number;
+            confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+            level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+            isProvisional: boolean;
+            calculatedAt: string;
+            components?: {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            } | undefined;
+        }, {
+            confidence: number;
+            score: number;
+            confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+            level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+            isProvisional: boolean;
+            calculatedAt: string;
+            components?: {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            } | undefined;
+        }>;
+        /** Context in which this reputation applies */
+        context: z.ZodOptional<z.ZodObject<{
+            /** Scope of the reputation (e.g., 'global', 'domain-specific') */
+            scope: z.ZodDefault<z.ZodString>;
+            /** Domain or category (e.g., 'e-commerce', 'healthcare') */
+            domain: z.ZodOptional<z.ZodString>;
+            /** Geographic region (if applicable) */
+            region: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            scope: string;
+            region?: string | undefined;
+            domain?: string | undefined;
+        }, {
+            region?: string | undefined;
+            scope?: string | undefined;
+            domain?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        reputation: {
+            confidence: number;
+            score: number;
+            confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+            level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+            isProvisional: boolean;
+            calculatedAt: string;
+            components?: {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            } | undefined;
+        };
+        context?: {
+            scope: string;
+            region?: string | undefined;
+            domain?: string | undefined;
+        } | undefined;
+    }, {
+        id: string;
+        reputation: {
+            confidence: number;
+            score: number;
+            confidenceLevel: "Low" | "Medium" | "High" | "VeryHigh";
+            level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+            isProvisional: boolean;
+            calculatedAt: string;
+            components?: {
+                priorScore: number;
+                empiricalScore: number;
+                confidenceWeight: number;
+                priorWeight: number;
+            } | undefined;
+        };
+        context?: {
+            region?: string | undefined;
+            scope?: string | undefined;
+            domain?: string | undefined;
+        } | undefined;
+    }>;
+    credentialStatus: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"StatusList2021Entry">;
+        statusPurpose: z.ZodEnum<["revocation", "suspension"]>;
+        statusListIndex: z.ZodString;
+        statusListCredential: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }>>;
+    proof: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">>;
+/**
+ * Validate a reputation attestation
+ *
+ * @param attestation - The attestation to validate
+ * @returns Validation result
+ */
+export declare function validateReputationAttestation(attestation: unknown): z.SafeParseReturnType<z.objectInputType<{
+    '@context': z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>, "atleastone">, [string | Record<string, any>, ...(string | Record<string, any>)[]], [string | Record<string, any>, ...(string | Record<string, any>)[]]>;
+    id: z.ZodOptional<z.ZodString>;
+    issuer: z.ZodUnion<[z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>]>;
+    issuanceDate: z.ZodString;
+    expirationDate: z.ZodOptional<z.ZodString>;
+    credentialStatus: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"StatusList2021Entry">;
+        statusPurpose: z.ZodEnum<["revocation", "suspension"]>;
+        statusListIndex: z.ZodString;
+        statusListCredential: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }>>;
+    proof: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+} & {
+    type: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+    credentialSubject: z.ZodObject<{
+        /** Subject DID */
+        id: z.ZodString;
+        /** Reputation level (human-readable) */
+        level: z.ZodEnum<["Unknown", "Poor", "BelowAverage", "Average", "Good", "Excellent", "Outstanding"]>;
+        /** Numeric score (0-100) */
+        score: z.ZodNumber;
+        /** Whether the attestation issuer has high confidence */
+        highConfidence: z.ZodBoolean;
+        /** Specific capability or context being attested */
+        capability: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        score: number;
+        level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+        highConfidence: boolean;
+        capability?: string | undefined;
+    }, {
+        id: string;
+        score: number;
+        level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+        highConfidence: boolean;
+        capability?: string | undefined;
+    }>;
+}, z.ZodTypeAny, "passthrough">, z.objectOutputType<{
+    '@context': z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>, "atleastone">, [string | Record<string, any>, ...(string | Record<string, any>)[]], [string | Record<string, any>, ...(string | Record<string, any>)[]]>;
+    id: z.ZodOptional<z.ZodString>;
+    issuer: z.ZodUnion<[z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>]>;
+    issuanceDate: z.ZodString;
+    expirationDate: z.ZodOptional<z.ZodString>;
+    credentialStatus: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"StatusList2021Entry">;
+        statusPurpose: z.ZodEnum<["revocation", "suspension"]>;
+        statusListIndex: z.ZodString;
+        statusListCredential: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }>>;
+    proof: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+} & {
+    type: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+    credentialSubject: z.ZodObject<{
+        /** Subject DID */
+        id: z.ZodString;
+        /** Reputation level (human-readable) */
+        level: z.ZodEnum<["Unknown", "Poor", "BelowAverage", "Average", "Good", "Excellent", "Outstanding"]>;
+        /** Numeric score (0-100) */
+        score: z.ZodNumber;
+        /** Whether the attestation issuer has high confidence */
+        highConfidence: z.ZodBoolean;
+        /** Specific capability or context being attested */
+        capability: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        score: number;
+        level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+        highConfidence: boolean;
+        capability?: string | undefined;
+    }, {
+        id: string;
+        score: number;
+        level: "Unknown" | "Poor" | "BelowAverage" | "Average" | "Good" | "Excellent" | "Outstanding";
+        highConfidence: boolean;
+        capability?: string | undefined;
+    }>;
+}, z.ZodTypeAny, "passthrough">>;
+/**
+ * Create an unsigned reputation credential (requires signing)
+ *
+ * @param agentDid - DID of the agent
+ * @param score - Reputation score
+ * @param issuerDid - DID of the issuing authority
+ * @param options - Optional credential options
+ * @returns Unsigned ReputationCredential
+ */
+export declare function createUnsignedReputationCredential(agentDid: string, score: ReputationScore, issuerDid: string, options?: {
+    id?: string;
+    expirationDate?: string;
+    credentialStatus?: z.infer<typeof CredentialStatusSchema>;
+    context?: {
+        scope?: string;
+        domain?: string;
+        region?: string;
+    };
+}): Omit<ReputationCredential, "proof">;
+/**
+ * Extract reputation score from a reputation credential
+ *
+ * @param credential - The reputation credential
+ * @returns Reputation score data
+ */
+export declare function extractReputationFromCredential(credential: ReputationCredential): ReputationScore;
+/**
+ * Check if a reputation credential has expired
+ *
+ * @param credential - The credential to check
+ * @returns true if expired
+ */
+export declare function isReputationCredentialExpired(credential: ReputationCredential): boolean;
+/**
+ * Check if the reputation score in a credential is stale
+ * (calculated too long ago to be reliable)
+ *
+ * @param credential - The credential to check
+ * @param maxAgeMs - Maximum age in milliseconds (default: 24 hours)
+ * @returns true if stale
+ */
+export declare function isReputationCredentialStale(credential: ReputationCredential, maxAgeMs?: number): boolean;
+/**
+ * Default reputation credential validity period (7 days)
+ */
+export declare const DEFAULT_REPUTATION_CREDENTIAL_VALIDITY_MS: number;
+/**
+ * Recommended maximum age for reputation scores (24 hours)
+ */
+export declare const RECOMMENDED_REPUTATION_FRESHNESS_MS: number;