type Input =
  | GeoJSON.Geometry          // Raw GeoJSON geometry
  | OnchainInput              // Onchain attestation reference
  | OffchainInput             // Offchain attestation reference (not yet implemented)
  | VerifiedProofInput;       // Verified location proof

{
  "type": "Point",
  "coordinates": [2.2945, 48.8584]
}

{
  "uid": "0xabc123..."
}

{
  "uid": "0xabc...",
  "uri": "ipfs://Qm..."
}

interface VerifiedProofInput {
  verifiedProof: VerifiedLocationProofResponse;
}

{
  "verifiedProof": {
    "proof": { "..." : "..." },
    "credibility": { "..." : "..." },
    "evaluationMethod": "multifactor-v0",
    "evaluatedAt": 1706961600
  }
}

interface LocationClaim {
  lpVersion: string;              // "0.2"
  locationType: string;           // "geojson-point", "h3-index", etc.
  location: GeoJSON.Geometry;     // The asserted location
  srs: string;                    // Spatial reference system URI

  subject: SubjectIdentifier;     // Who is making the claim
  radius: number;                 // Meters — required
  time: {
    start: number;                // Unix timestamp (seconds)
    end: number;
  };
  eventType?: string;             // "presence", "transaction", "delivery"
}

interface LocationStamp {
  lpVersion: string;
  locationType: string;
  location: GeoJSON.Geometry;     // The OBSERVED location
  srs: string;

  temporalFootprint: {
    start: number;                // Unix timestamp (seconds)
    end: number;
  };

  plugin: string;                 // "proofmode", "witnesschain", "mock"
  pluginVersion: string;
  signals: Record<string, unknown>;
  signatures: Signature[];
}

interface LocationProof {
  claim: LocationClaim;
  stamps: LocationStamp[];
}

interface SubjectIdentifier {
  scheme: string;   // "eth-address" | "device-pubkey" | "did:web"
  value: string;
}

{ "scheme": "eth-address", "value": "0x1234..." }
{ "scheme": "device-pubkey", "value": "0xabcd..." }

interface Signature {
  signer: SubjectIdentifier;
  algorithm: string;              // "secp256k1" | "ed25519"
  value: string;                  // Hex-encoded
  timestamp: number;              // Unix timestamp (seconds)
}

interface CredibilityVector {
  dimensions: {
    spatial: {
      meanDistanceMeters: number;
      maxDistanceMeters: number;
      withinRadiusFraction: number;     // 0-1
    };
    temporal: {
      meanOverlap: number;              // 0-1
      minOverlap: number;               // 0-1
      fullyOverlappingFraction: number; // 0-1
    };
    validity: {
      signaturesValidFraction: number;  // 0-1
      structureValidFraction: number;   // 0-1
      signalsConsistentFraction: number; // 0-1
    };
    independence: {
      uniquePluginRatio: number;        // 0-1
      spatialAgreement: number;         // 0-1
      pluginNames: string[];
    };
  };
  stampResults: StampResult[];
  meta: {
    stampCount: number;
    evaluatedAt: number;                // Unix timestamp (seconds)
    evaluationMode: 'local' | 'tee' | 'zk';
  };
}

interface StampResult {
  stampIndex: number;
  plugin: string;
  signaturesValid: boolean;
  structureValid: boolean;
  signalsConsistent: boolean;
  distanceMeters: number;         // Distance from stamp to claim location
  temporalOverlap: number;       // 0-1
  withinRadius: boolean;
  details: Record<string, unknown>; // Plugin-specific
}

interface AttestationData {
  schema: string;                 // Schema UID
  attester: string;               // Attester address
  recipient: string;              // Recipient address
  data: string;                   // ABI-encoded attestation data
  revocable: boolean;             // Whether the attestation can be revoked
  refUID: string;                 // Referenced attestation UID (zero bytes if none)
  signature: string;              // Hex-encoded signature
}

interface DelegatedAttestationData {
  signature: string;              // Hex-encoded EIP-712 signature
  attester: string;               // Attester address
  deadline: number;               // Unix timestamp — signature expiry
  nonce: number;                  // Attester nonce for replay protection
}

interface NumericComputeResponse {
  result: number;
  units: string;                  // "meters", "square_meters"
  operation: string;
  timestamp: number;
  inputRefs: string[];
  attestation: AttestationData;
  delegatedAttestation: DelegatedAttestationData;
}

interface BooleanComputeResponse {
  result: boolean;
  operation: string;
  timestamp: number;
  inputRefs: string[];
  attestation: AttestationData;
  delegatedAttestation: DelegatedAttestationData;
}

interface VerifiedLocationProofResponse {
  proof: LocationProof;
  credibility: CredibilityVector;
  evaluationMethod: string;
  evaluatedAt: number;            // Unix timestamp (seconds)
  attestation?: {
    uid: string;                  // Attestation UID
    schema: string;
    attester: string;
    recipient: string;
    data: string;
    revocable: boolean;
    refUID: string;
    time: number;                 // Attestation creation time
    expirationTime: number;       // 0 = no expiration
    revocationTime: number;       // 0 = not revoked
    signature?: string;
  };
  delegatedAttestation?: DelegatedAttestationData;
  chainId?: number;
}