@openagentid/oas-document

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

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

declare const AUTH_METHODS: {
    readonly DID_AUTH: "did-auth";
    readonly API_KEY: "api-key";
    readonly OAUTH2: "oauth2";
    readonly MTLS: "mtls";
    readonly BEARER_TOKEN: "bearer-token";
};

declare const BOOKING_TYPES: {
    readonly CONSULTATION: "consultation";
    readonly SUPPORT: "support";
    readonly MEETING: "meeting";
    readonly TASK: "task";
    readonly CUSTOM: "custom";
};

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 declare function compareConformanceLevel(a: ConformanceLevel, b: ConformanceLevel): number;

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 declare function createVerificationMethod(did: string, keyNum: number, keypair: OasKeyPair): VerificationMethod;

export declare function defaultContext(): ReadonlyArray<string>;

export declare function defaultGovernancePolicy(): GovernancePolicy;

declare const DID_CONTEXT: "https://www.w3.org/ns/did/v1";

export declare class DocumentBuilder {
    constructor(id: string, kind: EntityKind);
    controller(controller: string | ReadonlyArray<string>): this;
    addVerificationMethod(keypair: OasKeyPair): this;
    conformanceLevel(level: ConformanceLevel): this;
    lifecycleStatus(status: LifecycleStatus): this;
    sequence(seq: number): this;
    name(name: string): this;
    description(description: string): this;
    lineage(lineage: LineageSection): this;
    addService(service: ServiceEndpoint): this;
    metadata(metadata: Record<string, unknown>): this;
    buildAndSign(keypair: OasKeyPair, created: string): Promise<OasDocument>;
}

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

declare const DocumentErrorCode: {
    readonly MissingField: "MISSING_FIELD";
    readonly InvalidField: "INVALID_FIELD";
    readonly ProofVerificationFailed: "PROOF_VERIFICATION_FAILED";
    readonly ProofGenerationFailed: "PROOF_GENERATION_FAILED";
    readonly ConformanceNotMet: "CONFORMANCE_NOT_MET";
    readonly Json: "JSON_ERROR";
    readonly Did: "DID_ERROR";
    readonly Crypto: "CRYPTO_ERROR";
    readonly InvalidLifecycleTransition: "INVALID_LIFECYCLE_TRANSITION";
    readonly InvalidSequence: "INVALID_SEQUENCE";
};

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

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

export declare function documentWithoutProof(doc: OasDocument): Record<string, unknown>;

declare const ED25519_CONTEXT: "https://w3id.org/security/suites/ed25519-2020/v1";

declare const ENR_GOVERNANCE_PROOF_TYPE: "EnrGovernanceTransitionProof2025";

declare const ENTRY_TYPES: {
    readonly PHONE: "phone";
    readonly EMAIL: "email";
    readonly SOCIAL: "social";
    readonly WEBSITE: "website";
    readonly MESSAGING: "messaging";
};

export declare function extractKeyId(vmId: string): string | undefined;

export declare function findVerificationMethod(doc: OasDocument, vmId: string): VerificationMethod | undefined;

export declare function generateDocumentProof(documentWithoutProof: Record<string, unknown>, keypair: OasKeyPair, verificationMethodId: string, created: string): Promise<DocumentProof>;

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>;
}

export declare function isRevoked(doc: OasDocument): boolean;

export declare function isRootDocument(doc: OasDocument): boolean;

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>;
}

export declare function meetsConformanceLevel(actual: ConformanceLevel, required: ConformanceLevel): boolean;

declare const OAS_CONTEXT: "https://openagent.id/ns/oas/v1";

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 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>;
}

declare const PLATFORMS: {
    readonly X: "x";
    readonly LINKEDIN: "linkedin";
    readonly GITHUB: "github";
    readonly DISCORD: "discord";
    readonly TELEGRAM: "telegram";
    readonly SLACK: "slack";
    readonly WHATSAPP: "whatsapp";
    readonly SIGNAL: "signal";
    readonly MASTODON: "mastodon";
    readonly BLUESKY: "bluesky";
    readonly YOUTUBE: "youtube";
    readonly INSTAGRAM: "instagram";
    readonly TIKTOK: "tiktok";
    readonly REDDIT: "reddit";
};

declare const PRICING_MODELS: {
    readonly FREE: "free";
    readonly PER_REQUEST: "per_request";
    readonly PER_TOKEN: "per_token";
    readonly SUBSCRIPTION: "subscription";
    readonly NEGOTIATED: "negotiated";
    readonly CUSTOM: "custom";
};

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

export declare function primaryPublicKeyMultibase(doc: OasDocument): string | undefined;

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 PROTOCOLS: {
    readonly MCP: "mcp";
    readonly A2A: "a2a";
    readonly REST: "rest";
    readonly GRAPHQL: "graphql";
    readonly GRPC: "grpc";
    readonly WEBSOCKET: "websocket";
    readonly OAS_MAP: "oas-map";
};

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

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

declare const RELATIONSHIP_TYPES: {
    readonly MEMBER: "member";
    readonly PARTNER: "partner";
    readonly SUBSIDIARY: "subsidiary";
    readonly AFFILIATE: "affiliate";
    readonly DELEGATE: "delegate";
    readonly ADVISOR: "advisor";
};

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;
}

declare const SCHEDULING_PROTOCOLS: {
    readonly ICAL_INVITE: "ical-invite";
    readonly API: "api";
    readonly AGENT_NEGOTIATION: "agent-negotiation";
    readonly MANUAL: "manual";
};

declare const SERVICE_TYPES: {
    readonly OAS_ENTITY: "OASEntity";
    readonly OAS_COMMUNICATION: "OASCommunication";
    readonly OAS_LINEAGE_QUERY: "OASLineageQuery";
    readonly OAS_ATTESTATION: "OASAttestationService";
    readonly OAS_REVOCATION_STATUS: "OASRevocationStatus";
    readonly OAS_CAPABILITY_INVOCATION: "OASCapabilityInvocation";
    readonly OAS_GOVERNANCE: "OASGovernance";
    readonly OAS_PRIVATE_ENDPOINT: "OASPrivateEndpointService";
};

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 declare function verifyDocumentProof(documentWithoutProof: Record<string, unknown>, proof: DocumentProof, publicKeyBytes: Uint8Array): Promise<boolean>;

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

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;
}

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 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;
    };
}

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

declare const PROOF_TYPE: "AgentLineageProof2025";

sha512-FCFQNuVXmYDVoDoR5+9S31CO6H4xdOUq4z7FlheHRxRRwNHTrZtCRRUwP4ycnblWXu7eT6cXdWOXeo1lx0Vm8A==