@openagentid/aegis-sdk

interface ActiveHours {
    startHour: number;
    endHour: number;
    timezone: string;
}

declare const ActiveHoursSchema: z.ZodObject<{
    startHour: z.ZodNumber;
    endHour: z.ZodNumber;
    timezone: z.ZodString;
}, "strip", z.ZodTypeAny, {
    startHour: number;
    endHour: number;
    timezone: string;
}, {
    startHour: number;
    endHour: number;
    timezone: string;
}>;

declare class AddressDeriver {
    static derivationPath(chain: Chain, account: number, index: number): string;
    static deriveAddress(chain: Chain, publicKeyBytes: Uint8Array): WalletAddress;
    static deriveAll(publicKeyBytes: Uint8Array, chains: readonly Chain[]): WalletAddress[];
}

declare class AegisClient {
    readonly registry: PluginRegistry;
    readonly verifier: VerificationPipeline;
    readonly sessions: SessionManager;
    readonly delegations: DelegationTree;
    readonly config: AegisConfig;
    readonly stores: AegisStores;
    constructor(params: {
        registry: PluginRegistry;
        config?: AegisConfig;
        stores?: AegisStores;
    });
    static withDefaults(registry: PluginRegistry): AegisClient;
    withSigner(signer: SigningBackend): this;
    verifyIdentity(did: string): Promise<VerificationResult>;
    verifyIdentityFresh(did: string): Promise<VerificationResult>;
    authenticate(credential: AuthCredential, identityType: IdentityType): Promise<Session>;
    getSession(sessionId: string): Session;
    revokeSession(sessionId: string): void;
    isSessionValid(sessionId: string): boolean;
    authorize(request: PolicyRequest): Promise<PolicyDecision>;
    composePolicyDecisions(decisions: readonly PolicyDecision[]): PolicyDecision;
    delegate(params: {
        delegatorDid: string;
        delegateDid: string;
        scope: DelegationScope;
        expires?: string | null;
        signingKey: Uint8Array;
        verificationMethod: string;
    }): Delegation;
    verifyDelegation(delegation: Delegation, delegatorPublicKey: Uint8Array): boolean;
    revokeDelegation(delegationId: string): string[];
    signTransaction(tx: Transaction, auth: AuthContext, policyDecision: PolicyDecision): Promise<AuthorizedTransaction>;
    transactions(): TransactionPipeline | null;
}

interface AegisConfig {
    verification: VerificationConfig;
    sessions: SessionConfig;
    keys: KeyConfig;
    storageBackend: StorageBackend;
}

type AegisError = ResolverError | AuthError | PolicyError | VerificationError | KeyError | DelegationError | WalletError;

declare class AegisException extends Error {
    readonly error: AegisError;
    constructor(error: AegisError);
}

interface AegisIdentity {
    did: string;
    identityType: IdentityType;
    displayName?: string | null;
    conformanceLevel?: number | null;
}

interface AegisStores {
    sessionStore: SessionStore;
    nonceStore: NonceStore;
    delegationStore: DelegationStore;
    revocationStore: RevocationStore;
    keyStore: KeyStore;
    verificationCacheStore: VerificationCacheStore;
}

interface AgentLineageProof {
    type: string;
    verificationMethod: string;
    created: string;
    jws: string;
}

declare class ApiKeyProvider implements AuthProvider {
    constructor(initial?: Record<string, string>);
    providerName(): string;
    registerKey(key: string, did: string): void;
    revokeKey(key: string): boolean;
    validate(credential: AuthCredential): Promise<AuthContext>;
    getIdentity(ctx: AuthContext): Promise<AegisIdentity>;
}

interface AuditInfo {
    auditId: string;
    timestamp: string;
    engine: string;
    policiesEvaluated: string[];
}

interface AuthContext {
    provider: string;
    subject: string;
    did?: string | null;
    sessionId?: string | null;
    expiresAt?: string | null;
    claims: Record<string, unknown>;
}

type AuthCredential = {
    type: "bearer_token";
    token: string;
} | {
    type: "session_cookie";
    cookie: string;
} | {
    type: "api_key";
    key: string;
} | {
    type: "signed_challenge";
    did: string;
    challenge: string;
    signature: string;
    timestamp: string;
    nonce: string;
} | {
    type: "capability_token";
    token: string;
} | {
    type: "passkey_assertion";
    credentialId: string;
    authenticatorData: string;
    clientDataJson: string;
    signature: string;
} | {
    type: "custom";
    provider: string;
    data: unknown;
};

type AuthError = {
    kind: "auth/invalid_credential";
    reason: string;
    message: string;
} | {
    kind: "auth/credential_expired";
    expiredAt: string;
    message: string;
} | {
    kind: "auth/session_revoked";
    sessionId: string;
    message: string;
} | {
    kind: "auth/session_expired";
    sessionId: string;
    message: string;
} | {
    kind: "auth/challenge_invalid";
    reason: string;
    message: string;
} | {
    kind: "auth/provider_unavailable";
    provider: string;
    message: string;
} | {
    kind: "auth/refresh_not_supported";
    provider: string;
    message: string;
} | {
    kind: "auth/revocation_not_supported";
    provider: string;
    message: string;
} | {
    kind: "auth/internal";
    reason: string;
    message: string;
};

declare const authErrors: {
    invalidCredential: (reason: string) => AuthError;
    credentialExpired: (expiredAt: string) => AuthError;
    sessionRevoked: (sessionId: string) => AuthError;
    sessionExpired: (sessionId: string) => AuthError;
    challengeInvalid: (reason: string) => AuthError;
    providerUnavailable: (provider: string) => AuthError;
    refreshNotSupported: (provider: string) => AuthError;
    revocationNotSupported: (provider: string) => AuthError;
    internal: (reason: string) => AuthError;
};

interface AuthorizedTransaction {
    transaction: Transaction;
    signature: Uint8Array;
    fulfilledObligations: string[];
}

interface AuthProvider {
    validate(credential: AuthCredential): Promise<AuthContext>;
    getIdentity(ctx: AuthContext): Promise<AegisIdentity>;
    providerName(): string;
    refresh?(ctx: AuthContext): Promise<AuthContext>;
    revoke?(ctx: AuthContext): Promise<void>;
}

declare function base64UrlDecode(input: string): Uint8Array;

declare function base64UrlEncode(bytes: Uint8Array): string;

type BatchMode = "all_or_nothing" | "best_effort";

declare function buildChallengePayload(challenge: Challenge, did: string): Uint8Array;

type Chain = "ethereum" | "polygon" | "arbitrum" | "optimism" | "base" | "solana" | "bitcoin" | "cosmos" | "osmosis" | "aptos" | "sui" | "starknet";

declare const CHAIN_VALUES: readonly Chain[];

declare function chainCoinType(chain: Chain): number;

declare const ChainSchema: z.ZodEnum<[
    "ethereum",
    "polygon",
    "arbitrum",
    "optimism",
    "base",
    "solana",
    "bitcoin",
    "cosmos",
    "osmosis",
    "aptos",
    "sui",
    "starknet"
]>;

interface Challenge {
    challengeBytes: Uint8Array;
    timestamp: string;
    nonce: string;
    expiresAt: string;
}

declare class ChallengeResponseProvider implements AuthProvider {
    constructor(resolver: DidResolver);
    providerName(): string;
    verifier(): ChallengeVerifier;
    validate(credential: AuthCredential): Promise<AuthContext>;
    getIdentity(ctx: AuthContext): Promise<AegisIdentity>;
}

declare class ChallengeVerifier {
    verifyResponse(challenge: Challenge, did: string, signatureB64: string, publicKey: Uint8Array): void;
    clearNonces(): void;
}

declare function composeDecisions(decisions: readonly PolicyDecision[]): PolicyDecision;

declare function concatBytes(...chunks: Uint8Array[]): Uint8Array;

interface ContractInteraction {
    contractAddress: string;
    functionName: string;
    chain: string;
    gasEstimate?: number | null;
}

interface ContractPolicy {
    contractAllowlist: string[];
    functionAllowlist: string[];
    chainAllowlist: string[];
    gasLimit?: number | null;
}

declare class ContractPolicyEvaluator {
    static evaluate(policy: ContractPolicy, interaction: ContractInteraction): PolicyDecision;
}

declare function createDelegationProof(params: {
    delegatorDid: string;
    delegateDid: string;
    scope: DelegationScope;
    expires?: string | null;
    signingKey: Uint8Array;
    verificationMethod: string;
}): Delegation;

interface CreateDidParams {
    entityKind: string;
    namespace: string;
    identifier: string;
    metadata: Record<string, string>;
}

interface CreatedSessionKey {
    sessionKey: SessionKey;
    ephemeralSigningKey: Uint8Array;
    ephemeralVerifyingKey: Uint8Array;
}

declare function createSessionKey(params: {
    principalDid: string;
    scope: DelegationScope;
    maxTransactions?: number | null;
    lifetimeMs: number;
    principalSigningKey: Uint8Array;
    verificationMethod: string;
}): CreatedSessionKey;

declare function cryptoBackend(): CryptoBackend;

interface CryptoBackend {
    ed25519GenerateKeypair(): {
        signingKey: Uint8Array;
        verifyingKey: Uint8Array;
    };
    ed25519PublicFromPrivate(signingKey: Uint8Array): Uint8Array;
    ed25519Sign(signingKey: Uint8Array, message: Uint8Array): Uint8Array;
    ed25519Verify(verifyingKey: Uint8Array, message: Uint8Array, signature: Uint8Array): boolean;
    hkdfSha256(ikm: Uint8Array, salt: Uint8Array, info: Uint8Array, length: number): Uint8Array;
    blake3Hash(input: Uint8Array): Uint8Array;
    sha256(input: Uint8Array): Uint8Array;
    sha512(input: Uint8Array): Uint8Array;
    aes256GcmEncrypt(key: Uint8Array, nonce: Uint8Array, plaintext: Uint8Array): Uint8Array;
    aes256GcmDecrypt(key: Uint8Array, nonce: Uint8Array, ciphertext: Uint8Array): Uint8Array;
    jcsCanonicalize(value: unknown): Uint8Array;
    multibaseEncode(bytes: Uint8Array): string;
    multibaseDecode(encoded: string): Uint8Array;
    randomBytes(length: number): Uint8Array;
    frostTrustedKeygen(minSigners: number, maxSigners: number): {
        keyPackages: FrostKeyPackage[];
        publicKeyPackage: Uint8Array;
    };
    frostSignRound1(signingShare: Uint8Array): {
        nonces: Uint8Array;
        commitments: Uint8Array;
    };
    frostSignRound2(signingPackage: Uint8Array, nonces: Uint8Array, keyPackage: Uint8Array): Uint8Array;
    frostBuildSigningPackage(commitments: Map<number, Uint8Array>, message: Uint8Array): Uint8Array;
    frostAggregate(signingPackage: Uint8Array, signatureShares: Map<number, Uint8Array>, publicKeyPackage: Uint8Array): Uint8Array;
    frostVerify(publicKeyPackage: Uint8Array, message: Uint8Array, signature: Uint8Array): boolean;
}

declare const DEFAULT_AEGIS_CONFIG: AegisConfig;

declare const DEFAULT_KEY_CONFIG: KeyConfig;

declare const DEFAULT_PAGE_SIZE = 100;

declare const DEFAULT_PAGINATION: Pagination;

declare const DEFAULT_SESSION_CONFIG: SessionConfig;

declare const DEFAULT_VERIFICATION_CONFIG: VerificationConfig;

declare function defaultAegisStores(): AegisStores;

interface Delegation {
    id: string;
    delegator: string;
    delegate: string;
    scope: DelegationScope;
    created: string;
    expires?: string | null;
    revocable: boolean;
    proof: DelegationProof;
}

type DelegationError = {
    kind: "delegation/invalid_proof";
    reason: string;
    message: string;
} | {
    kind: "delegation/revoked";
    delegationId: string;
    message: string;
} | {
    kind: "delegation/expired";
    delegationId: string;
    message: string;
} | {
    kind: "delegation/max_depth_exceeded";
    depth: number;
    maxDepth: number;
    message: string;
} | {
    kind: "delegation/scope_amplification";
    reason: string;
    message: string;
} | {
    kind: "delegation/delegator_not_found";
    did: string;
    message: string;
} | {
    kind: "delegation/delegate_not_found";
    did: string;
    message: string;
};

declare const delegationErrors: {
    invalidProof: (reason: string) => DelegationError;
    revoked: (delegationId: string) => DelegationError;
    expired: (delegationId: string) => DelegationError;
    maxDepthExceeded: (depth: number, maxDepth: number) => DelegationError;
    scopeAmplification: (reason: string) => DelegationError;
    delegatorNotFound: (did: string) => DelegationError;
    delegateNotFound: (did: string) => DelegationError;
};

interface DelegationProof {
    type: "AegisDelegationProof2025";
    verificationMethod: string;
    created: string;
    jws: string;
}

declare const DelegationProofSchema: z.ZodObject<{
    type: z.ZodLiteral<"AegisDelegationProof2025">;
    verificationMethod: z.ZodString;
    created: z.ZodString;
    jws: z.ZodString;
}, "strip", z.ZodTypeAny, {
    type: "AegisDelegationProof2025";
    verificationMethod: string;
    created: string;
    jws: string;
}, {
    type: "AegisDelegationProof2025";
    verificationMethod: string;
    created: string;
    jws: string;
}>;

declare const DelegationSchema: z.ZodObject<{
    id: z.ZodString;
    delegator: z.ZodString;
    delegate: z.ZodString;
    scope: z.ZodObject<{
        actions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        resources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        chains: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        limits: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            maxAmount: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            dailyVolume: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            assetAllowlist: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
            recipientAllowlist: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
            approvalThreshold: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        }, "strip", z.ZodTypeAny, {
            assetAllowlist: string[];
            recipientAllowlist: string[];
            maxAmount?: string | null | undefined;
            dailyVolume?: string | null | undefined;
            approvalThreshold?: string | null | undefined;
        }, {
            maxAmount?: string | null | undefined;
            dailyVolume?: string | null | undefined;
            assetAllowlist?: string[] | undefined;
            recipientAllowlist?: string[] | undefined;
            approvalThreshold?: string | null | undefined;
        }>>>;
        temporal: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            validFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            validUntil: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            activeHours: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                startHour: z.ZodNumber;
                endHour: z.ZodNumber;
                timezone: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                startHour: number;
                endHour: number;
                timezone: string;
            }, {
                startHour: number;
                endHour: number;
                timezone: string;
            }>>>;
            cooldown: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        }, "strip", z.ZodTypeAny, {
            validFrom?: string | null | undefined;
            validUntil?: string | null | undefined;
            activeHours?: {
                startHour: number;
                endHour: number;
                timezone: string;
            } | null | undefined;
            cooldown?: string | null | undefined;
        }, {
            validFrom?: string | null | undefined;
            validUntil?: string | null | undefined;
            activeHours?: {
                startHour: number;
                endHour: number;
                timezone: string;
            } | null | undefined;
            cooldown?: string | null | undefined;
        }>>>;
    }, "strip", z.ZodTypeAny, {
        actions: string[];
        resources: string[];
        chains: string[];
        limits?: {
            assetAllowlist: string[];
            recipientAllowlist: string[];
            maxAmount?: string | null | undefined;
            dailyVolume?: string | null | undefined;
            approvalThreshold?: string | null | undefined;
        } | null | undefined;
        temporal?: {
            validFrom?: string | null | undefined;
            validUntil?: string | null | undefined;
            activeHours?: {
                startHour: number;
                endHour: number;
                timezone: string;
            } | null | undefined;
            cooldown?: string | null | undefined;
        } | null | undefined;
    }, {
        actions?: string[] | undefined;
        resources?: string[] | undefined;
        chains?: string[] | undefined;
        limits?: {
            maxAmount?: string | null | undefined;
            dailyVolume?: string | null | undefined;
            assetAllowlist?: string[] | undefined;
            recipientAllowlist?: string[] | undefined;
            approvalThreshold?: string | null | undefined;
        } | null | undefined;
        temporal?: {
            validFrom?: string | null | undefined;
            validUntil?: string | null | undefined;
            activeHours?: {
                startHour: number;
                endHour: number;
                timezone: string;
            } | null | undefined;
            cooldown?: string | null | undefined;
        } | null | undefined;
    }>;
    created: z.ZodString;
    expires: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    revocable: z.ZodBoolean;
    proof: z.ZodObject<{
        type: z.ZodLiteral<"AegisDelegationProof2025">;
        verificationMethod: z.ZodString;
        created: z.ZodString;
        jws: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        type: "AegisDelegationProof2025";
        verificationMethod: string;
        created: string;
        jws: string;
    }, {
        type: "AegisDelegationProof2025";
        verificationMethod: string;
        created: string;
        jws: string;
    }>;
}, "strip", z.ZodTypeAny, {
    created: string;
    id: string;
    delegator: string;
    delegate: string;
    scope: {
        actions: string[];
        resources: string[];
        chains: string[];
        limits?: {
            assetAllowlist: string[];
            recipientAllowlist: string[];
            maxAmount?: string | null | undefined;
            dailyVolume?: string | null | undefined;
            approvalThreshold?: string | null | undefined;
        } | null | undefined;
        temporal?: {
            validFrom?: string | null | undefined;
            validUntil?: string | null | undefined;
            activeHours?: {
                startHour: number;
                endHour: number;
                timezone: string;
            } | null | undefined;
            cooldown?: string | null | undefined;
        } | null | undefined;
    };
    revocable: boolean;
    proof: {
        type: "AegisDelegationProof2025";
        verificationMethod: string;
        created: string;
        jws: string;
    };
    expires?: string | null | undefined;
}, {
    created: string;
    id: string;
    delegator: string;
    delegate: string;
    scope: {
        actions?: string[] | undefined;
        resources?: string[] | undefined;
        chains?: string[] | undefined;
        limits?: {
            maxAmount?: string | null | undefined;
            dailyVolume?: string | null | undefined;
            assetAllowlist?: string[] | undefined;
            recipientAllowlist?: string[] | undefined;
            approvalThreshold?: string | null | undefined;
        } | null | undefined;
        temporal?: {
            validFrom?: string | null | undefined;
            validUntil?: string | null | undefined;
            activeHours?: {
                startHour: number;
                endHour: number;
                timezone: string;
            } | null | undefined;
            cooldown?: string | null | undefined;
        } | null | undefined;
    };
    revocable: boolean;
    proof: {
        type: "AegisDelegationProof2025";
        verificationMethod: string;
        created: string;
        jws: string;
    };
    expires?: string | null | undefined;
}>;

interface DelegationScope {
    actions: string[];
    resources: string[];
    chains: string[];
    limits?: SpendingLimits | null;
    temporal?: TemporalConstraints | null;
}

declare const DelegationScopeSchema: z.ZodObject<{
    actions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    resources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    chains: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    limits: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        maxAmount: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        dailyVolume: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        assetAllowlist: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        recipientAllowlist: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        approvalThreshold: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "strip", z.ZodTypeAny, {
        assetAllowlist: string[];
        recipientAllowlist: string[];
        maxAmount?: string | null | undefined;
        dailyVolume?: string | null | undefined;
        approvalThreshold?: string | null | undefined;
    }, {
        maxAmount?: string | null | undefined;
        dailyVolume?: string | null | undefined;
        assetAllowlist?: string[] | undefined;
        recipientAllowlist?: string[] | undefined;
        approvalThreshold?: string | null | undefined;
    }>>>;
    temporal: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        validFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        validUntil: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        activeHours: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            startHour: z.ZodNumber;
            endHour: z.ZodNumber;
            timezone: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            startHour: number;
            endHour: number;
            timezone: string;
        }, {
            startHour: number;
            endHour: number;
            timezone: string;
        }>>>;
        cooldown: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, "strip", z.ZodTypeAny, {
        validFrom?: string | null | undefined;
        validUntil?: string | null | undefined;
        activeHours?: {
            startHour: number;
            endHour: number;
            timezone: string;
        } | null | undefined;
        cooldown?: string | null | undefined;
    }, {
        validFrom?: string | null | undefined;
        validUntil?: string | null | undefined;
        activeHours?: {
            startHour: number;
            endHour: number;
            timezone: string;
        } | null | undefined;
        cooldown?: string | null | undefined;
    }>>>;
}, "strip", z.ZodTypeAny, {
    actions: string[];
    resources: string[];
    chains: string[];
    limits?: {
        assetAllowlist: string[];
        recipientAllowlist: string[];
        maxAmount?: string | null | undefined;
        dailyVolume?: string | null | undefined;
        approvalThreshold?: string | null | undefined;
    } | null | undefined;
    temporal?: {
        validFrom?: string | null | undefined;
        validUntil?: string | null | undefined;
        activeHours?: {
            startHour: number;
            endHour: number;
            timezone: string;
        } | null | undefined;
        cooldown?: string | null | undefined;
    } | null | undefined;
}, {
    actions?: string[] | undefined;
    resources?: string[] | undefined;
    chains?: string[] | undefined;
    limits?: {
        maxAmount?: string | null | undefined;
        dailyVolume?: string | null | undefined;
        assetAllowlist?: string[] | undefined;
        recipientAllowlist?: string[] | undefined;
        approvalThreshold?: string | null | undefined;
    } | null | undefined;
    temporal?: {
        validFrom?: string | null | undefined;
        validUntil?: string | null | undefined;
        activeHours?: {
            startHour: number;
            endHour: number;
            timezone: string;
        } | null | undefined;
        cooldown?: string | null | undefined;
    } | null | undefined;
}>;

interface DelegationStore {
    storeDelegation(delegation: Delegation): Promise<void>;
    getDelegation(id: string): Promise<Delegation | null>;
    listByDelegator(delegatorDid: string, pagination?: Pagination): Promise<Delegation[]>;
    listByDelegate(delegateDid: string, pagination?: Pagination): Promise<Delegation[]>;
    deleteDelegation(id: string): Promise<boolean>;
}

declare class DelegationTree {
    readonly maxDepth: number;
    constructor(maxDepth?: number);
    addDelegation(delegation: Delegation): void;
    getDelegationChain(delegateDid: string): Delegation[];
    effectiveScope(delegateDid: string): DelegationScope | null;
    depth(delegateDid: string): number;
    revoke(delegationId: string): string[];
}

declare function derivationPath(chain: Chain, account: number, index: number): string;

declare function derivationStandard(chain: Chain): "BIP-44" | "SLIP-0010";

declare function deriveLineageKey(parentPrivate: Uint8Array, childDid: string, generation: number): Uint8Array;

interface DidCreationResult {
    did: string;
    document: OasDocument;
}

interface DidResolver {
    resolve(did: string): Promise<OasDocument>;
    handles(did: string): boolean;
    supportedMethods(): readonly string[];
    create?(params: CreateDidParams): Promise<DidCreationResult>;
    update?(did: string, document: OasDocument): Promise<void>;
    deactivate?(did: string): Promise<void>;
}

declare class DirectSigner implements SigningBackend {
    constructor(signingKey: Uint8Array);
    sign(request: SigningRequest): Promise<SigningResult>;
    publicKey(): Uint8Array;
    mode(): SigningMode;
}

interface DocumentMetadata {
    created: string;
    updated?: string | null;
}

interface DocumentProof {
    type: string;
    verificationMethod: string;
    created: string;
    jws?: string;
    proofValue?: string;
}

declare class EncryptedKey {
    readonly ciphertext: Uint8Array;
    readonly nonce: Uint8Array;
    static encrypt(signingKeyBytes: Uint8Array, encryptionKey: Uint8Array): EncryptedKey;
    decrypt(encryptionKey: Uint8Array): Uint8Array;
    static fromParts(ciphertext: Uint8Array, nonce: Uint8Array): EncryptedKey;
}

type EntityKind = "hmr" | "mhr" | "enr" | "ao" | "agent" | "agent:instance" | "tool" | "skill" | "workflow" | "model" | "dataset" | "service";

declare class FrostCeremony {
    constructor(publicKeyPackage: Uint8Array, threshold: number);
    addCommitment(id: number, commitments: Uint8Array): void;
    hasEnoughCommitments(): boolean;
    buildSigningPackage(message: Uint8Array): Uint8Array;
    addSignatureShare(id: number, share: Uint8Array): void;
    hasEnoughShares(): boolean;
    aggregate(): Uint8Array;
}

interface FrostKeyPackage {
    identifier: number;
    bytes: Uint8Array;
}

declare function generateChallenge(): Challenge;

declare function generateShares(minSigners: number, maxSigners: number): ThresholdKeyPackages;

interface Guardian {
    guardianType: GuardianType;
    identifier: string;
    weight: number;
}

interface GuardianAuthorization {
    guardian: Guardian;
    authorizedAt: string;
    signature: string;
}

type GuardianType = "identity" | "email" | "phone" | "hardware";

declare function hexDecode(input: string): Uint8Array;

declare function hexEncode(bytes: Uint8Array): string;

type IdentityType = "human" | "agent" | "organization" | "enterprise" | "delegated";

declare const IdentityTypeSchema: z.ZodEnum<[
    "human",
    "agent",
    "organization",
    "enterprise",
    "delegated"
]>;

declare function inferIdentityTypeFromDid(did: string): "human" | "organization" | "enterprise" | "agent";

declare class InMemoryDelegationStore implements DelegationStore {
    storeDelegation(delegation: Delegation): Promise<void>;
    getDelegation(id: string): Promise<Delegation | null>;
    listByDelegator(delegatorDid: string, pagination?: Pagination): Promise<Delegation[]>;
    listByDelegate(delegateDid: string, pagination?: Pagination): Promise<Delegation[]>;
    deleteDelegation(id: string): Promise<boolean>;
}

declare class InMemoryKeyStore implements KeyStore {
    size(): number;
    isEmpty(): boolean;
    store(key: ManagedKey): Promise<void>;
    load(keyId: string): Promise<ManagedKey>;
    delete(keyId: string): Promise<void>;
    list(role: KeyRole | null, pagination?: Pagination): Promise<string[]>;
}