@openagentid/oas-lineage

export declare function defaultVerifyConfig(): VerifyConfig;

export declare function deriveChildEntity(parentKeypair: OasKeyPair, parentDoc: OasDocument, childDid: string, derivationPath: string): Promise<DerivedChild>;

export interface DerivedChild {
    readonly keypair: OasKeyPair;
    readonly lineage: LineageSection;
}

export interface DocumentProvider {
    resolve(did: string): Promise<OasDocument | undefined>;
}

export declare class InMemoryProvider implements DocumentProvider {
    register(doc: OasDocument): void;
    remove(did: string): boolean;
    resolve(did: string): Promise<OasDocument | undefined>;
    get size(): number;
    get isEmpty(): boolean;
}

export declare class LineageError extends Error {
    readonly code: LineageErrorCode;
    readonly details: Readonly<Record<string, unknown>>;
    constructor(code: LineageErrorCode, message: string, details?: Record<string, unknown>);
}

declare const LineageErrorCode: {
    readonly MissingLineage: "MISSING_LINEAGE";
    readonly EmptyChain: "EMPTY_CHAIN";
    readonly ChainNotTerminatingAtRoot: "CHAIN_NOT_TERMINATING_AT_ROOT";
    readonly GenerationMismatch: "GENERATION_MISMATCH";
    readonly ChainTooDeep: "CHAIN_TOO_DEEP";
    readonly ResolutionFailed: "RESOLUTION_FAILED";
    readonly ParentRevoked: "PARENT_REVOKED";
    readonly ParentSignatureInvalid: "PARENT_SIGNATURE_INVALID";
    readonly UnknownProofType: "UNKNOWN_PROOF_TYPE";
    readonly ProofParentMismatch: "PROOF_PARENT_MISMATCH";
    readonly ProofChildMismatch: "PROOF_CHILD_MISMATCH";
    readonly ProofSignatureInvalid: "PROOF_SIGNATURE_INVALID";
    readonly TotalTimeout: "TOTAL_TIMEOUT";
    readonly MissingDerivationProof: "MISSING_DERIVATION_PROOF";
    readonly ParentKeyNotFound: "PARENT_KEY_NOT_FOUND";
    readonly Crypto: "CRYPTO_ERROR";
};

export type LineageErrorCode = (typeof LineageErrorCode)[keyof typeof LineageErrorCode];

export interface VerifyConfig {
    readonly maxGeneration: number;
    readonly perHopTimeoutMs: number;
    readonly totalTimeoutMs: number;
    readonly verifyDocumentSignatures: boolean;
}

export declare function verifyConfigWithMaxGeneration(maxGeneration: number): VerifyConfig;

export declare function verifyConfigWithTimeouts(perHopTimeoutMs: number, totalTimeoutMs: number): VerifyConfig;

export declare function verifyLineage(doc: OasDocument, provider: DocumentProvider, config?: VerifyConfig): Promise<VerifyResult>;

export declare function verifyLineageStructural(doc: OasDocument, maxGeneration?: number): VerifyResult;

export interface VerifyResult {
    readonly chainLength: number;
    readonly humanRootDid: string;
    readonly warnings: ReadonlyArray<string>;
}

export interface Affiliation {
    readonly did: string;
    readonly relationship: string;
    readonly label?: string;
}

export interface AgentLineageProofData {
    readonly proofType: typeof PROOF_TYPE;
    readonly parentDid: string;
    readonly childDid: string;
    readonly derivationPath: string;
    readonly algorithm: typeof PROOF_ALGORITHM;
    readonly publicKeyMultibase: string;
    readonly signature: string;
}

export interface ApiSchema {
    readonly schemaType: string;
    readonly url: string;
    readonly version?: string;
}

export interface BookingEndpoint {
    readonly id: string;
    readonly url: string;
    readonly label?: string;
    readonly bookingType?: string;
    readonly visibility?: Visibility;
}

export interface CalendarSection {
    readonly bookingEndpoints?: ReadonlyArray<BookingEndpoint>;
    readonly availabilityFeed?: string;
    readonly schedulingProtocol?: string;
    readonly officeHours?: ReadonlyArray<ScheduleWindow>;
    readonly timezone?: string;
}

export interface Certification {
    readonly standard: string;
    readonly issuer?: string;
    readonly validUntil?: string;
    readonly url?: string;
}

export interface ComplianceSection {
    readonly jurisdictions?: ReadonlyArray<string>;
    readonly certifications?: ReadonlyArray<Certification>;
    readonly termsOfServiceUrl?: string;
    readonly privacyPolicyUrl?: string;
    readonly dataHandlingPolicyUrl?: string;
    readonly dataResidency?: string;
}

declare const ConformanceLevel: {
    readonly L0: "L0";
    readonly L1: "L1";
    readonly L2: "L2";
};

export type ConformanceLevel = (typeof ConformanceLevel)[keyof typeof ConformanceLevel];

export interface ContactEntry {
    readonly id: string;
    readonly entryType: string;
    readonly value: string;
    readonly label?: string;
    readonly platform?: string;
    readonly handle?: string;
    readonly visibility?: Visibility;
    readonly verified?: boolean;
}

export interface ContactSection {
    readonly entries: ReadonlyArray<ContactEntry>;
}

export interface CostEntry {
    readonly unit: string;
    readonly amount: string;
    readonly currency: string;
}

export interface DocumentProof {
    readonly type: 'Ed25519Signature2020';
    readonly created: string;
    readonly verificationMethod: string;
    readonly proofPurpose: 'assertionMethod';
    readonly proofValue: string;
}

declare const EntityKind: {
    readonly Hmr: "hmr";
    readonly Mhr: "mhr";
    readonly Enr: "enr";
    readonly Ao: "ao";
    readonly Agent: "agent";
    readonly AgentInstance: "agent:instance";
    readonly Tool: "tool";
    readonly Skill: "skill";
    readonly Workflow: "workflow";
    readonly Model: "model";
    readonly Dataset: "dataset";
    readonly Service: "service";
};

export type EntityKind = (typeof EntityKind)[keyof typeof EntityKind];

export interface GovernancePolicy {
    readonly transitionRequires: string;
    readonly signingKeyRotationRequires: string;
    readonly maxTransitionsPerDay: number;
    readonly timelockHours: number;
}

export interface GovernanceSection {
    readonly currentMhr: string;
    readonly epoch: number;
    readonly transitions: ReadonlyArray<GovernanceTransition>;
    readonly policy: GovernancePolicy;
}

export interface GovernanceTransition {
    readonly from?: string | undefined;
    readonly to: string;
    readonly epoch: number;
    readonly proof: GovernanceTransitionProof;
}

export interface GovernanceTransitionProof {
    readonly type: string;
    readonly mhrThresholdSignature: string;
    readonly timestamp: string;
}

export interface InteroperabilitySection {
    readonly protocols?: ReadonlyArray<ProtocolSupport>;
    readonly apiSchemas?: ReadonlyArray<ApiSchema>;
    readonly authMethods?: ReadonlyArray<string>;
}

declare const LifecycleStatus: {
    readonly Nascent: "nascent";
    readonly Active: "active";
    readonly Dormant: "dormant";
    readonly Suspended: "suspended";
    readonly Terminated: "terminated";
    readonly Archived: "archived";
};

export type LifecycleStatus = (typeof LifecycleStatus)[keyof typeof LifecycleStatus];

export interface LineageSection {
    readonly humanRootDid: string;
    readonly creatorDid: string;
    readonly generation: number;
    readonly derivationProof?: AgentLineageProofData | undefined;
    readonly humanRootChain: ReadonlyArray<string>;
}

declare const OAS_VERSION: "1.0.0";

export interface OasDocument {
    readonly '@context': ReadonlyArray<string>;
    readonly id: string;
    readonly controller: string | ReadonlyArray<string>;
    readonly verificationMethod: ReadonlyArray<VerificationMethod>;
    readonly authentication: ReadonlyArray<string>;
    readonly assertionMethod: ReadonlyArray<string>;
    readonly capabilityInvocation: ReadonlyArray<string>;
    readonly capabilityDelegation: ReadonlyArray<string>;
    readonly service: ReadonlyArray<ServiceEndpoint>;
    readonly oasVersion: typeof OAS_VERSION;
    readonly kind: EntityKind;
    readonly name?: string | undefined;
    readonly description?: string | undefined;
    readonly lineage?: LineageSection | undefined;
    readonly conformanceLevel: ConformanceLevel;
    readonly lifecycleStatus?: LifecycleStatus | undefined;
    readonly sequence: number;
    readonly metadata: Readonly<Record<string, unknown>>;
    readonly proof?: DocumentProof | undefined;
    readonly revoked?: boolean | undefined;
    readonly revokedAt?: string | undefined;
    readonly profile?: ProfileSection | undefined;
    readonly contact?: ContactSection | undefined;
    readonly calendar?: CalendarSection | undefined;
    readonly operational?: OperationalSection | undefined;
    readonly pricing?: PricingSection | undefined;
    readonly interoperability?: InteroperabilitySection | undefined;
    readonly reputation?: ReputationSection | undefined;
    readonly compliance?: ComplianceSection | undefined;
    readonly relationships?: RelationshipsSection | undefined;
    readonly governance?: GovernanceSection | undefined;
}

export declare class OasKeyPair {
    static generate(): Promise<OasKeyPair>;
    static fromSigningKeyBytes(bytes: Uint8Array): Promise<OasKeyPair>;
    static verifyingKeyFromBytes(bytes: Uint8Array): Uint8Array;
    sign(message: Uint8Array): Promise<Uint8Array>;
    static verifyWithKey(publicKeyBytes: Uint8Array, message: Uint8Array, signatureBytes: Uint8Array): Promise<boolean>;
    get signingKeyBytes(): Uint8Array;
    get verifyingKeyBytes(): Uint8Array;
    publicKeyMultibase(): string;
    toString(): string;
    toJSON(): {
        verifyingKey: string;
    };
}

export interface OperationalSection {
    readonly availability?: string;
    readonly sla?: ReadonlyArray<SlaCommitment>;
    readonly rateLimits?: ReadonlyArray<RateLimit>;
    readonly supportedInputFormats?: ReadonlyArray<string>;
    readonly supportedOutputFormats?: ReadonlyArray<string>;
    readonly maxPayloadBytes?: number;
    readonly maxContextTokens?: number;
    readonly maintenanceWindows?: ReadonlyArray<ScheduleWindow>;
}

export interface PricingSection {
    readonly model: string;
    readonly costs?: ReadonlyArray<CostEntry>;
    readonly currenciesAccepted?: ReadonlyArray<string>;
    readonly billingEndpoint?: string;
    readonly freeTierLimits?: string;
    readonly billingVisibility?: Visibility;
}

export interface ProfileSection {
    readonly avatarUrl?: string;
    readonly bannerUrl?: string;
    readonly tagline?: string;
    readonly categories?: ReadonlyArray<string>;
    readonly languages?: ReadonlyArray<string>;
    readonly timezone?: string;
    readonly accentColor?: string;
}

declare const PROOF_ALGORITHM: "HKDF-SHA256-Ed25519";

declare const PROOF_TYPE: "AgentLineageProof2025";

export interface ProtocolSupport {
    readonly protocol: string;
    readonly version?: string;
    readonly endpoint?: string;
}

export interface RateLimit {
    readonly resource: string;
    readonly limit: number;
    readonly window: string;
}

export interface RelationshipsSection {
    readonly parentOrganization?: string;
    readonly affiliations?: ReadonlyArray<Affiliation>;
    readonly blockedDids?: ReadonlyArray<string>;
}

export interface ReputationSection {
    readonly totalInteractions?: number;
    readonly endorsementCount?: number;
    readonly trustScore?: string;
    readonly uptime30d?: string;
    readonly uptime90d?: string;
    readonly firstActive?: string;
    readonly endorserDids?: ReadonlyArray<string>;
}

export interface ScheduleWindow {
    readonly day: string;
    readonly start: string;
    readonly end: string;
    readonly timezone: string;
}

export interface ServiceEndpoint {
    readonly id: string;
    readonly type: string;
    readonly serviceEndpoint: string;
    readonly label?: string;
    readonly description?: string;
    readonly properties?: Readonly<Record<string, string>>;
}

export interface SlaCommitment {
    readonly metric: string;
    readonly target: string;
}

export interface VerificationMethod {
    readonly id: string;
    readonly type: 'Ed25519VerificationKey2020';
    readonly controller: string;
    readonly publicKeyMultibase: string;
}

export type Visibility = 'public' | 'authenticated' | 'organization' | 'private';

sha512-adM9P4Xf6qYLbKeYTLsBYVok94bMVpedcTMtsqI2m6+cuFlLSoMfZYKiK1b19hini7qj+0OwdAzoM/ufHpgppw==