@agentunion/fastaun 0.5.18 → 0.5.20

package/dist/ownership-v21.d.ts

@@ -0,0 +1,196 @@
+import { AID } from './aid.js';
+import { StateError } from './errors.js';
+export type OwnershipFileRole = 'agent' | 'owner';
+export type OwnershipConsensusStatus = 'consensus' | 'released' | 'unbound' | 'single_sided' | 'invalid' | 'unavailable' | 'not_applicable';
+export interface OwnershipStatementV21 {
+    version: 2;
+    declaration_id: string;
+    owner_aid: string;
+    sub_aid: string;
+    relation_version: number;
+    declared_at: number;
+}
+export interface OwnershipTransferV21 {
+    new_owner_aid: string;
+    target_relation_version: number;
+    expires_at: number;
+}
+export interface OwnershipFileContext {
+    expectedSubAid?: string;
+    expectedOwnerAid?: string;
+    expectedTargetAid?: string;
+    authenticatedAid?: string;
+    certificateAid?: string;
+    resourcePath?: string;
+    storagePath?: string;
+    now?: number;
+    requireSignature?: boolean;
+    certificateResolver?: (aid: string, fingerprint: string, timestamp: number) => OwnershipCertificate;
+}
+export interface OwnershipCertificate {
+    cert_pem: string;
+    chain_valid: boolean;
+    state: string;
+    revoked: boolean;
+    revocation_checked: boolean;
+    observed_at: number;
+}
+export interface OwnershipFile {
+    raw: Uint8Array;
+    payload: string;
+    frontmatter: Record<string, unknown>;
+    signature: Record<string, string> | null;
+    statement?: OwnershipStatementV21;
+    action?: 'declare' | 'release' | 'transfer_owner';
+    transfer?: OwnershipTransferV21;
+}
+export interface OwnershipConsensusResult {
+    status: OwnershipConsensusStatus;
+    sub_aid: string;
+    owner_aid: string | null;
+    relation_version: number;
+    lock: 'locked' | 'unlocked';
+    agent_md_etag: string;
+    agent_md_sha256: string;
+    owner_md_sha256: string;
+    code?: string;
+    reason?: string;
+    retryable?: boolean;
+}
+export declare const OWNERSHIP_UUID_V4_RE: RegExp;
+export declare function ownershipAid(value: unknown, field: string): string;
+export declare function ownershipInteger(value: unknown, field: string, min?: number): number;
+export declare function validateOwnershipStatement(value: unknown): OwnershipStatementV21;
+export declare function validateOwnershipAgentFrontmatter(meta: Record<string, unknown>, expectedAid?: string): OwnershipStatementV21 | undefined;
+export declare function parseOwnershipFile(content: string | Uint8Array, role: OwnershipFileRole, context?: OwnershipFileContext): OwnershipFile;
+export declare function verifyOwnershipFile(content: string | Uint8Array, role: OwnershipFileRole, certificate: OwnershipCertificate, context?: OwnershipFileContext): OwnershipFile;
+export declare function signOwnershipFile(identity: AID, content: string | Uint8Array, role: OwnershipFileRole, context?: OwnershipFileContext): string;
+export declare function ownershipSha256(content: string | Uint8Array): string;
+export interface OwnershipAgentObservation {
+    sub_aid: string;
+    exists: boolean;
+    content: string;
+    etag: string;
+    protocol: string;
+    relation_version: number;
+    lock: 'locked' | 'unlocked';
+    owner_aid?: string | null;
+    observed_at: number;
+    recovery_ready?: boolean;
+}
+export interface OwnershipOwnerObservation {
+    owner_aid: string;
+    sub_aid?: string;
+    bucket: string;
+    path: string;
+    exists: boolean;
+    observed_at: number;
+    sha256?: string;
+    content: string;
+    authoritative: boolean;
+    recovery_ready?: boolean;
+    service_aid: string;
+    authenticated_service_aid: string;
+    version?: number;
+}
+export interface OwnershipSavedFile {
+    raw: string;
+    hash: string;
+    condition: {
+        if_match?: string;
+        if_none_match?: string;
+    };
+    published_etag?: string;
+    original_owner?: {
+        exists: boolean;
+        raw: string;
+        sha256: string;
+    };
+    expires_at?: number;
+    deleted?: boolean;
+}
+export interface OwnershipFileTask {
+    operation_id?: string;
+    operation: 'bind' | 'release' | 'transfer';
+    sub_aid: string;
+    owner_aid: string;
+    new_owner_aid?: string;
+    base_relation_version: number;
+    target_relation_version: number;
+    files: Record<string, OwnershipSavedFile>;
+    expected_agent_statement?: OwnershipStatementV21;
+    base_agent_md?: {
+        exists: boolean;
+        raw: string;
+        sha256: string;
+        etag: string;
+        statement: OwnershipStatementV21 | null;
+    };
+    base_owner_md?: {
+        exists: boolean;
+        raw: string;
+        sha256: string;
+    };
+    authorization_sha256?: string;
+    expires_at?: number;
+    persist(): Promise<void>;
+}
+export interface OwnershipFileDependencies {
+    currentAid(): AID;
+    currentType?(): string;
+    now(): number;
+    readAgentMdFresh(subAid: string): Promise<OwnershipAgentObservation>;
+    submitAgentMdRaw(subAid: string, raw: string, condition: OwnershipSavedFile['condition']): Promise<OwnershipAgentObservation>;
+    readOwnerMd(ownerAid: string, subAid: string): Promise<OwnershipOwnerObservation>;
+    writeOwnerMd(ownerAid: string, subAid: string, raw: string): Promise<OwnershipOwnerObservation>;
+    deleteOwnerMd(ownerAid: string, subAid: string): Promise<unknown>;
+    resolveCertificate(aid: string, fingerprint: string, purpose?: 'signing' | 'group_identity'): Promise<OwnershipCertificate>;
+}
+export declare function ownershipFailure(code: string, reason: string, retryable?: boolean): StateError;
+export declare function requireOwnershipApplicable(type: unknown): void;
+export declare class OwnershipFiles {
+    private readonly deps;
+    constructor(deps: OwnershipFileDependencies);
+    checkConsensus(subAid: string, target?: {
+        owner_aid: string;
+        relation_version: number;
+    }): Promise<OwnershipConsensusResult>;
+    declareSubaid(task: OwnershipFileTask): Promise<OwnershipOwnerObservation>;
+    declareOwneraid(task: OwnershipFileTask): Promise<OwnershipAgentObservation>;
+    revokeSubaid(task: OwnershipFileTask): Promise<OwnershipOwnerObservation>;
+    revokeOwneraid(task: OwnershipFileTask): Promise<OwnershipAgentObservation>;
+    transferOwneraid(task: OwnershipFileTask): Promise<OwnershipOwnerObservation>;
+    cleanupOwnerFile(task: OwnershipFileTask): Promise<void>;
+    readAgent(subAid: string): Promise<OwnershipAgentObservation>;
+    readOwner(ownerAid: string, subAid: string): Promise<OwnershipOwnerObservation>;
+    verifyFile(raw: string, role: OwnershipFileRole, subAid: string, ownerAid?: string): Promise<OwnershipFile>;
+    requireTransfer(task: OwnershipFileTask): Promise<OwnershipFile>;
+    private targetOwner;
+    private requireLocal;
+    private statement;
+    private assertBase;
+    private requireOriginal;
+    private savedFile;
+    private validSavedCondition;
+    private publishOwner;
+    private publishAgent;
+}
+interface OwnershipStorageDependencies {
+    currentAid(): string;
+    call(method: string, params: Record<string, unknown>): Promise<unknown>;
+    httpPut?(url: string, data: Uint8Array, headers?: Record<string, string>): Promise<void>;
+    now?(): number;
+}
+export declare class OwnershipStorageAdapter {
+    private readonly deps;
+    constructor(deps: OwnershipStorageDependencies);
+    private now;
+    private call;
+    private metadata;
+    readObject(ownerAid: string, path: string): Promise<OwnershipOwnerObservation>;
+    readOwnerMd(ownerAid: string, subAid: string): Promise<OwnershipOwnerObservation>;
+    writeOwnerMd(ownerAid: string, subAid: string, raw: string): Promise<OwnershipOwnerObservation>;
+    deleteOwnerMd(ownerAid: string, subAid: string): Promise<void>;
+    private requireLocal;
+}
+export {};