Types

interface AgentConfig {
  domain: string;
  path?: string;
  algorithm?: Algorithm;
  storage?: StorageAdapter;
}

interface AgentIdentity {
  did: string;
  didDocument: DIDDocument;
  keyPair: KeyPair;
  domain: string;
  path?: string;
}

interface DelegateOptions {
  agent: string;
  owner: string;
  ownerKeyPair: KeyPair;
  scopes: string[];
  constraints?: DelegationConstraints;
  validFrom?: string;
  validUntil?: string;
  statusList?: { url: string; index: number };
  parentDelegation?: {
    token: string;
    parentOwnerPublicKey: Uint8Array;
  };
  maxChainDepth?: number;
}

interface DelegationCredential {
  token: string;
  claims: DelegationClaims;
}

interface DelegationClaims {
  agent: string;
  owner: string;
  scopes: string[];
  constraints?: DelegationConstraints;
  validFrom?: string;
  validUntil?: string;
}

interface DelegationConstraints {
  maxTransactionValue?: number;
  validUntil?: string;
  allowedDomains?: string[];
  rateLimit?: number;
  [key: string]: unknown;
}

type DelegationResult =
  | {
      valid: true;
      agent: string;
      owner: string;
      scopes: string[];
      constraints?: DelegationConstraints;
      validFrom?: string;
      validUntil?: string;
      errors: [];
    }
  | {
      valid: false;
      agent?: string;
      owner?: string;
      scopes?: string[];
      constraints?: DelegationConstraints;
      validFrom?: string;
      validUntil?: string;
      errors: VerificationError[];
    };

const result = await verifyDelegation(token, options);
 
if (result.valid) {
  // TypeScript knows: agent, owner, scopes are strings/arrays (not undefined)
  console.log(result.agent, result.scopes);
} else {
  // TypeScript knows: errors is VerificationError[] with at least one entry
  for (const err of result.errors) {
    console.log(err.code, err.message);
  }
}

interface ChallengeMessage {
  type: "credat:challenge";
  nonce: string;
  from: string;
  timestamp: string;
}

interface PresentationMessage {
  type: "credat:presentation";
  delegation: string;
  nonce: string;
  proof: string;
  from: string;
}

interface AckMessage {
  type: "credat:ack";
  verified: boolean;
  scopes?: string[];
  counterChallenge?: ChallengeMessage;
  delegation?: string;
  proof?: string;
  from?: string;
}

type HandshakeMessage = ChallengeMessage | PresentationMessage | AckMessage;

function handle(msg: HandshakeMessage) {
  switch (msg.type) {
    case "credat:challenge":
      // msg is ChallengeMessage
      break;
    case "credat:presentation":
      // msg is PresentationMessage
      break;
    case "credat:ack":
      // msg is AckMessage
      break;
  }
}

type DIDMethod = "key" | "web";

interface DIDDocument {
  id: string;
  verificationMethod?: VerificationMethod[];
  authentication?: string[];
  assertionMethod?: string[];
  service?: ServiceEndpoint[];
}

interface VerificationMethod {
  id: string;
  type: string;
  controller: string;
  publicKeyJwk?: JsonWebKey;
  publicKeyMultibase?: string;
}

interface ServiceEndpoint {
  id: string;
  type: string;
  serviceEndpoint: string;
}

interface DIDResolutionResult {
  didDocument: DIDDocument | null;
  didResolutionMetadata: { error?: string };
  didDocumentMetadata: Record<string, unknown>;
}

interface HasScopes {
  scopes: string[];
}

interface ConstraintContext {
  transactionValue?: number;
  domain?: string;
  rateLimit?: number;
  [key: string]: unknown;
}

interface ConstraintViolation {
  constraint: string;
  message: string;
}

type CredentialFormat = "sd-jwt-vc";

type CredentialClaimValue =
  | string
  | number
  | boolean
  | null
  | CredentialClaimValue[]
  | { [key: string]: CredentialClaimValue };

interface CredentialClaims {
  [key: string]: CredentialClaimValue;
}

interface VerificationError {
  code: ErrorCode;
  message: string;
  humanMessage?: string;
}

interface StatusListData {
  bitstring: Uint8Array;
  issuer: string;
  id: string;
  size: number;
}

interface StatusListEntry {
  statusListUrl: string;
  statusListIndex: number;
}

type RevocationStatus = "valid" | "revoked" | "unknown";

type Algorithm = "ES256" | "EdDSA";

interface KeyPair {
  algorithm: Algorithm;
  privateKey: Uint8Array;
  publicKey: Uint8Array;
}

interface JsonWebKey {
  kty: string;
  crv?: string;
  x?: string;
  y?: string;
  d?: string;
  kid?: string;
  alg?: string;
  use?: string;
}

interface StorageAdapter {
  get<T>(collection: string, key: string): Promise<T | null>;
  set<T>(collection: string, key: string, value: T): Promise<void>;
  delete(collection: string, key: string): Promise<boolean>;
  list<T>(collection: string): Promise<Array<{ key: string; value: T }>>;
  clear(collection?: string): Promise<void>;
}