@agentunion/fastaun 0.5.26 → 0.5.27

package/dist/semantic-facade.d.ts

@@ -0,0 +1,176 @@
+import type { CredentialSigner } from './org-protocol.js';
+import { type AID, type AuthorizationRequest, type AuthenticatedAUNContext, type CredentialLineageEntry, type CredentialPackage, type CredentialRevisionRef, type CredentialStatusProof, type DecisionInput, type Digest, type JsonObject, type PolicyRef, type RecordVerificationContext, type SemanticCredential, type SemanticErrorData, type SemanticFacadeInput, type SemanticGetParams, type SemanticGetResult, type SemanticRegisterParams, type SemanticRegisterResult, type SemanticReviseParams, type SemanticReviseResult, type SemanticRevokeParams, type SemanticRevokeResult, type SemanticRevocationListParams, type SemanticRevocationPage, type SemanticStatusParams, type SemanticUsageInput, type SemanticVerificationReport, type SignatureDomain, type SignedJsonBytes, type StateCheckPolicy, type UsageTransitionReceipt, type VerifiedBody, type UsageAllocation, type AllocationStatusProof, type AUNEvidenceLocator, type EvidenceRef, type EvidenceResolver, type SemanticMessageArchive, type SemanticMessageVerificationContext } from './semantic-protocol.js';
+export type { SemanticMessageArchive, SemanticMessageVerificationContext } from './semantic-protocol.js';
+type Raw = Record<string, any>;
+export interface SemanticPersistentState {
+    sequences?: Record<string, {
+        state_seq: number;
+        status: string;
+        revision: CredentialRevisionRef;
+    }>;
+    revoked?: Record<string, true>;
+    scopes?: Record<string, {
+        after_event_seq: number;
+        upper_event_seq: number;
+        next_cursor: string | null;
+    }>;
+    requests?: Record<string, {
+        request_hash: Digest;
+        nonce: string;
+        expires_at: number;
+        accepted?: boolean;
+    }>;
+    nonces?: Record<string, {
+        request_id: string;
+        request_hash: Digest;
+        expires_at: number;
+    }>;
+    mergedPages?: Record<string, true>;
+    allocations?: Record<string, {
+        allocation_hash: Digest;
+        state_seq: number;
+        state: AllocationStatusProof['state'];
+    }>;
+    proofs?: Record<string, true>;
+}
+export interface SemanticFacadeClient {
+    call(method: string, params: any): Promise<any>;
+    readonly aid?: string | null;
+    readonly currentAid?: CredentialSigner | null;
+    _semanticServiceAid?(): string | Promise<string>;
+    _semanticContextKey?(): string;
+    _semanticVerificationContext?(): RecordVerificationContext;
+    _semanticMessageVerificationContext?(): SemanticMessageVerificationContext;
+    _loadSemanticState?(): SemanticPersistentState | Promise<SemanticPersistentState>;
+    _saveSemanticState?(state: SemanticPersistentState): void | Promise<void>;
+}
+export interface SemanticFacadeOptions {
+    serviceAid?: string;
+    verificationContext?: RecordVerificationContext;
+    monotonicNow?: () => number;
+}
+export interface SemanticOperationOptions {
+    serviceAid?: string;
+    verificationContext?: RecordVerificationContext;
+}
+export interface SemanticPackageVerificationContext extends Partial<RecordVerificationContext> {
+    audience: AID;
+    expectedServiceAid?: AID;
+    originalSigner?: (entry: CredentialLineageEntry) => AID | Promise<AID>;
+    serviceFor?: (cid: string) => AID | Promise<AID>;
+    legacyVerifier?: (entry: CredentialLineageEntry, audience: AID, now: number) => void | Promise<void>;
+    statePolicy?: StateCheckPolicy;
+    elapsedSeconds?: number;
+    queries?: Record<string, {
+        request_hash: Digest;
+        nonce: string;
+    }>;
+}
+export interface SemanticAllocationVerificationContext extends Partial<RecordVerificationContext> {
+    parent: CredentialLineageEntry;
+    child: CredentialLineageEntry;
+    audience: AID;
+}
+export interface SemanticAllocationStatusVerificationContext extends Partial<RecordVerificationContext> {
+    allocation: UsageAllocation;
+    query: {
+        request_hash: Digest;
+        nonce: string;
+    };
+    elapsedSeconds: number;
+}
+export declare class SemanticRPCFailure extends Error {
+    readonly data: SemanticErrorData;
+    readonly code = -32000;
+    readonly retryable: boolean;
+    constructor(message: string, data: SemanticErrorData);
+}
+export declare class SemanticCredentialFacade {
+    private readonly client;
+    private readonly options;
+    private state;
+    private tail;
+    private readonly proofFirstSeen;
+    private readonly allocationProofFirstSeen;
+    private readonly statusCache;
+    constructor(client: SemanticFacadeClient, options?: SemanticFacadeOptions);
+    configure(options: SemanticFacadeOptions): void;
+    private clock;
+    private monotonic;
+    private identity;
+    private guard;
+    private service;
+    private context;
+    private mutate;
+    private invoke;
+    private responseRecord;
+    private registered;
+    private revisionHeads;
+    register(input: SemanticFacadeInput<SemanticRegisterParams>, options?: SemanticOperationOptions): Promise<SemanticRegisterResult>;
+    revise(input: SemanticFacadeInput<SemanticReviseParams>, options?: SemanticOperationOptions): Promise<SemanticReviseResult>;
+    prepareUsage(input: SemanticUsageInput<'usage_prepare'>, options?: SemanticOperationOptions): Promise<UsageTransitionReceipt>;
+    commitUsage(input: SemanticUsageInput<'usage_commit'>, options?: SemanticOperationOptions): Promise<UsageTransitionReceipt>;
+    abortUsage(input: SemanticUsageInput<'usage_abort'>, options?: SemanticOperationOptions): Promise<UsageTransitionReceipt>;
+    get(input: SemanticFacadeInput<SemanticGetParams>, options?: SemanticOperationOptions): Promise<SemanticGetResult>;
+    private proofIdentity;
+    private rememberProof;
+    private observe;
+    status(input: SemanticFacadeInput<SemanticStatusParams>, options?: SemanticOperationOptions): Promise<CredentialStatusProof>;
+    revoke(input: SemanticFacadeInput<SemanticRevokeParams>, options?: SemanticOperationOptions): Promise<SemanticRevokeResult>;
+    revocations(input: SemanticFacadeInput<SemanticRevocationListParams>, options?: SemanticOperationOptions): Promise<SemanticRevocationPage>;
+    private signer;
+    signCredential(value: unknown, signer?: CredentialSigner, options?: {
+        timestamp?: number;
+    }): Promise<SignedJsonBytes>;
+    signMetadata(value: unknown, signer?: CredentialSigner, options?: {
+        timestamp?: number;
+    }): Promise<SignedJsonBytes>;
+    verifyAllocation(value: unknown, context: SemanticAllocationVerificationContext): Promise<SemanticVerificationReport>;
+    signAllocation(value: unknown, signer?: CredentialSigner, options?: {
+        timestamp?: number;
+    }): Promise<SignedJsonBytes>;
+    signUsageRecord(domain: SignatureDomain, value: unknown, signer?: CredentialSigner, options?: {
+        timestamp?: number;
+    }): Promise<SignedJsonBytes>;
+    verifyAllocationStatus(value: unknown, context: SemanticAllocationStatusVerificationContext): Promise<SemanticVerificationReport>;
+    verifyUsageRecord(domain: SignatureDomain, value: unknown, context?: Partial<RecordVerificationContext>): Promise<SemanticVerificationReport>;
+    verifyOriginal(value: unknown, context?: Partial<RecordVerificationContext>): Promise<SemanticVerificationReport>;
+    verifyMetadata(value: unknown, context?: Partial<RecordVerificationContext>): Promise<SemanticVerificationReport>;
+    verifyReceipt(value: unknown, context?: Partial<RecordVerificationContext>): Promise<SemanticVerificationReport>;
+    verifyStatus(value: unknown, context?: Partial<RecordVerificationContext> & {
+        expectedServiceAid?: string;
+        policy?: StateCheckPolicy;
+        elapsedSeconds?: number;
+        query?: {
+            request_hash: Digest;
+            nonce: string;
+        };
+    }): Promise<SemanticVerificationReport>;
+    buildPackage(lineage: CredentialLineageEntry[]): Promise<CredentialPackage>;
+    private effective;
+    private lineageBindings;
+    verifyPackage(value: CredentialPackage, context: SemanticPackageVerificationContext): Promise<SemanticVerificationReport>;
+    requestHash(request: Omit<AuthorizationRequest, 'request_binding'> | AuthorizationRequest): Promise<Digest>;
+    buildRequest(input: Omit<AuthorizationRequest, 'params_hash' | 'request_binding'>, options?: {
+        now?: number;
+    }): Promise<AuthorizationRequest>;
+    private requestShape;
+    private rememberRequest;
+    verifyRequest(request: AuthorizationRequest, authentication: AuthenticatedAUNContext, options?: {
+        now?: number;
+        representedActor?: (actor: string, sub: string) => boolean | Promise<boolean>;
+    }): Promise<{
+        request_hash: Digest;
+        checked: string[];
+        required: string[];
+    }>;
+    buildDecisionInput(request: AuthorizationRequest, bodies: VerifiedBody[], facts: JsonObject, policy: PolicyRef): Promise<DecisionInput>;
+    createEvidenceRef(bytes: Uint8Array, profile: string, locator?: AUNEvidenceLocator): Promise<EvidenceRef>;
+    resolveEvidence(ref: EvidenceRef, resolvers?: Record<string, EvidenceResolver>): Promise<Uint8Array>;
+    archiveMessage(envelope: Uint8Array | string | Raw, received: {
+        received_by: string;
+        received_at: number;
+        source: string;
+    }): Promise<SemanticMessageArchive>;
+    verifyMessageBody(value: SemanticCredential | SignedJsonBytes, context?: Partial<SemanticMessageVerificationContext>): Promise<VerifiedBody>;
+}