@agledger/sdk 1.1.0

package/dist/resources/disputes.js

@@ -0,0 +1,26 @@
+/**
+ * AGLedger™ SDK — Disputes Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ */
+export class DisputesResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async create(mandateId, params, options) {
+        return this.http.post(`/v1/mandates/${mandateId}/dispute`, params, options);
+    }
+    async get(mandateId, options) {
+        return this.http.get(`/v1/mandates/${mandateId}/dispute`, undefined, options);
+    }
+    async escalate(mandateId, reason, options) {
+        return this.http.post(`/v1/mandates/${mandateId}/dispute/escalate`, { reason }, options);
+    }
+    async submitEvidence(mandateId, evidence, options) {
+        return this.http.post(`/v1/mandates/${mandateId}/dispute/evidence`, evidence, options);
+    }
+    async resolve(mandateId, params, options) {
+        return this.http.post(`/v1/mandates/${mandateId}/dispute/resolve`, params, options);
+    }
+}
+//# sourceMappingURL=disputes.js.map

package/dist/resources/events.d.ts

@@ -0,0 +1,21 @@
+/**
+ * AGLedger™ SDK — Events & Audit Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ */
+import type { HttpClient } from '../http.js';
+import type { AgledgerEvent, AuditChain, Page, ListParams, RequestOptions } from '../types.js';
+export declare class EventsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List events globally. Requires `since` parameter (ISO timestamp).
+     * GET /v1/events?since=...&order=asc|desc
+     */
+    list(params: {
+        since: string;
+        order?: 'asc' | 'desc';
+    } & ListParams, options?: RequestOptions): Promise<Page<AgledgerEvent>>;
+    /** Get the hash-chained audit trail for a mandate. */
+    getAuditChain(mandateId: string, options?: RequestOptions): Promise<AuditChain>;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/resources/events.js

@@ -0,0 +1,22 @@
+/**
+ * AGLedger™ SDK — Events & Audit Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ */
+export class EventsResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * List events globally. Requires `since` parameter (ISO timestamp).
+     * GET /v1/events?since=...&order=asc|desc
+     */
+    async list(params, options) {
+        return this.http.getPage('/v1/events', params, options);
+    }
+    /** Get the hash-chained audit trail for a mandate. */
+    async getAuditChain(mandateId, options) {
+        return this.http.get(`/v1/mandates/${mandateId}/audit`, undefined, options);
+    }
+}
+//# sourceMappingURL=events.js.map

package/dist/resources/health.d.ts

@@ -0,0 +1,15 @@
+/**
+ * AGLedger™ SDK — Health & Conformance Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ */
+import type { HttpClient } from '../http.js';
+import type { HealthResponse, StatusResponse, ConformanceResponse, RequestOptions } from '../types.js';
+export declare class HealthResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    check(options?: RequestOptions): Promise<HealthResponse>;
+    status(options?: RequestOptions): Promise<StatusResponse>;
+    /** Get platform conformance info (protocol version, features, limits). */
+    conformance(options?: RequestOptions): Promise<ConformanceResponse>;
+}
+//# sourceMappingURL=health.d.ts.map

package/dist/resources/health.js

@@ -0,0 +1,21 @@
+/**
+ * AGLedger™ SDK — Health & Conformance Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ */
+export class HealthResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async check(options) {
+        return this.http.get('/health', undefined, options);
+    }
+    async status(options) {
+        return this.http.get('/status', undefined, options);
+    }
+    /** Get platform conformance info (protocol version, features, limits). */
+    async conformance(options) {
+        return this.http.get('/v1/conformance', undefined, options);
+    }
+}
+//# sourceMappingURL=health.js.map

package/dist/resources/mandates.d.ts

@@ -0,0 +1,48 @@
+/**
+ * AGLedger™ SDK — Mandates Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ */
+import type { HttpClient } from '../http.js';
+import type { Mandate, CreateMandateParams, UpdateMandateParams, ListMandatesParams, SearchMandatesParams, DelegateMandateParams, CreateAgentMandateParams, RespondToMandateParams, Page, BulkCreateResult, MandateTransitionAction, RequestOptions, AutoPaginateOptions, TypedCreateMandateParams } from '../types.js';
+export declare class MandatesResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Create a mandate. When `contractType` is a known Agentic Contract
+     * Specification type, `criteria` is typed to that contract's schema.
+     */
+    create<T extends string>(params: TypedCreateMandateParams<T>, options?: RequestOptions): Promise<Mandate>;
+    create(params: CreateMandateParams, options?: RequestOptions): Promise<Mandate>;
+    /** Create a mandate via agent auth (POST /v1/mandates/agent). */
+    createAgent(params: CreateAgentMandateParams, options?: RequestOptions): Promise<Mandate>;
+    get(id: string, options?: RequestOptions): Promise<Mandate>;
+    list(params: ListMandatesParams, options?: RequestOptions): Promise<Page<Mandate>>;
+    /** Auto-paginating iterator. Yields individual mandates across all pages. */
+    listAll(params: ListMandatesParams, options?: RequestOptions & AutoPaginateOptions): AsyncGenerator<Mandate>;
+    search(params: SearchMandatesParams, options?: RequestOptions): Promise<Page<Mandate>>;
+    update(id: string, params: UpdateMandateParams, options?: RequestOptions): Promise<Mandate>;
+    transition(id: string, action: MandateTransitionAction, reason?: string, options?: RequestOptions): Promise<Mandate>;
+    cancel(id: string, reason?: string, options?: RequestOptions): Promise<Mandate>;
+    /** Accept a PROPOSED mandate (as performer). */
+    accept(id: string, options?: RequestOptions): Promise<Mandate>;
+    /** Reject a PROPOSED mandate (as performer). */
+    reject(id: string, reason?: string, options?: RequestOptions): Promise<Mandate>;
+    /** Respond to a PROPOSED mandate (accept, reject, or counter). */
+    respond(id: string, params: RespondToMandateParams, options?: RequestOptions): Promise<Mandate>;
+    /** Accept a counter-proposal on a mandate. */
+    acceptCounter(id: string, options?: RequestOptions): Promise<Mandate>;
+    /** Get the full delegation chain for a mandate. */
+    getChain(id: string, options?: RequestOptions): Promise<Mandate[]>;
+    /** Get direct sub-mandates of a mandate. */
+    getSubMandates(id: string, options?: RequestOptions): Promise<Page<Mandate>>;
+    /** Delegate a mandate by creating a child mandate via agent auth. */
+    delegate(id: string, params: DelegateMandateParams, options?: RequestOptions): Promise<Mandate>;
+    bulkCreate(mandates: CreateMandateParams[], options?: RequestOptions): Promise<BulkCreateResult>;
+    /** Get audit trail for a mandate. */
+    getAudit(id: string, options?: RequestOptions): Promise<Record<string, unknown>>;
+    /** List mandates where the authenticated agent is principal. */
+    listAsPrincipal(options?: RequestOptions): Promise<Page<Mandate>>;
+    /** List mandates proposed to the authenticated agent. */
+    listProposals(options?: RequestOptions): Promise<Page<Mandate>>;
+}
+//# sourceMappingURL=mandates.d.ts.map

package/dist/resources/mandates.js

@@ -0,0 +1,89 @@
+/**
+ * AGLedger™ SDK — Mandates Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ */
+export class MandatesResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async create(params, options) {
+        return this.http.post('/v1/mandates', params, options);
+    }
+    /** Create a mandate via agent auth (POST /v1/mandates/agent). */
+    async createAgent(params, options) {
+        return this.http.post('/v1/mandates/agent', params, options);
+    }
+    async get(id, options) {
+        return this.http.get(`/v1/mandates/${id}`, undefined, options);
+    }
+    async list(params, options) {
+        return this.http.getPage('/v1/mandates', params, options);
+    }
+    /** Auto-paginating iterator. Yields individual mandates across all pages. */
+    listAll(params, options) {
+        return this.http.paginate('/v1/mandates', params, options);
+    }
+    async search(params, options) {
+        return this.http.getPage('/v1/mandates/search', params, options);
+    }
+    async update(id, params, options) {
+        return this.http.patch(`/v1/mandates/${id}`, params, options);
+    }
+    async transition(id, action, reason, options) {
+        const body = { action };
+        if (reason)
+            body.reason = reason;
+        return this.http.post(`/v1/mandates/${id}/transition`, body, options);
+    }
+    async cancel(id, reason, options) {
+        return this.transition(id, 'cancel', reason, options);
+    }
+    /** Accept a PROPOSED mandate (as performer). */
+    async accept(id, options) {
+        return this.http.post(`/v1/mandates/${id}/accept`, undefined, options);
+    }
+    /** Reject a PROPOSED mandate (as performer). */
+    async reject(id, reason, options) {
+        return this.http.post(`/v1/mandates/${id}/reject`, reason ? { reason } : undefined, options);
+    }
+    /** Respond to a PROPOSED mandate (accept, reject, or counter). */
+    async respond(id, params, options) {
+        return this.http.post(`/v1/mandates/${id}/respond`, params, options);
+    }
+    /** Accept a counter-proposal on a mandate. */
+    async acceptCounter(id, options) {
+        return this.http.post(`/v1/mandates/${id}/accept-counter`, undefined, options);
+    }
+    /** Get the full delegation chain for a mandate. */
+    async getChain(id, options) {
+        return this.http.get(`/v1/mandates/${id}/chain`, undefined, options);
+    }
+    /** Get direct sub-mandates of a mandate. */
+    async getSubMandates(id, options) {
+        return this.http.getPage(`/v1/mandates/${id}/sub-mandates`, undefined, options);
+    }
+    /** Delegate a mandate by creating a child mandate via agent auth. */
+    async delegate(id, params, options) {
+        return this.createAgent({
+            ...params,
+            parentMandateId: id,
+        }, options);
+    }
+    async bulkCreate(mandates, options) {
+        return this.http.post('/v1/mandates/bulk', { mandates }, options);
+    }
+    /** Get audit trail for a mandate. */
+    async getAudit(id, options) {
+        return this.http.get(`/v1/mandates/${id}/audit`, undefined, options);
+    }
+    /** List mandates where the authenticated agent is principal. */
+    async listAsPrincipal(options) {
+        return this.http.getPage('/v1/mandates/agent/principal', undefined, options);
+    }
+    /** List mandates proposed to the authenticated agent. */
+    async listProposals(options) {
+        return this.http.getPage('/v1/mandates/agent/proposals', undefined, options);
+    }
+}
+//# sourceMappingURL=mandates.js.map

package/dist/resources/notarize.d.ts

@@ -0,0 +1,20 @@
+/**
+ * AGLedger™ SDK — Notarize Resource
+ * Agent-to-agent agreement notarization (OpenClaw flow).
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ */
+import type { HttpClient } from '../http.js';
+import type { NotarizedMandate, NotarizeMandateParams, NotarizeMandateResult, NotarizeCounterProposeParams, NotarizeReceiptParams, NotarizeReceiptResult, NotarizeVerdictParams, NotarizeVerifyParams, NotarizeVerifyResult, NotarizeHistory, RequestOptions } from '../types.js';
+export declare class NotarizeResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    createMandate(params: NotarizeMandateParams, options?: RequestOptions): Promise<NotarizeMandateResult>;
+    getMandate(id: string, options?: RequestOptions): Promise<NotarizedMandate>;
+    getHistory(id: string, options?: RequestOptions): Promise<NotarizeHistory>;
+    acceptMandate(id: string, options?: RequestOptions): Promise<NotarizedMandate>;
+    counterPropose(id: string, params: NotarizeCounterProposeParams, options?: RequestOptions): Promise<NotarizeMandateResult>;
+    submitReceipt(id: string, params: NotarizeReceiptParams, options?: RequestOptions): Promise<NotarizeReceiptResult>;
+    renderVerdict(id: string, params: NotarizeVerdictParams, options?: RequestOptions): Promise<NotarizedMandate>;
+    verify(params: NotarizeVerifyParams, options?: RequestOptions): Promise<NotarizeVerifyResult>;
+}
+//# sourceMappingURL=notarize.d.ts.map

package/dist/resources/notarize.js

@@ -0,0 +1,44 @@
+/**
+ * AGLedger™ SDK — Notarize Resource
+ * Agent-to-agent agreement notarization (OpenClaw flow).
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ */
+export class NotarizeResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    // --- Principal: create a notarized mandate ---
+    async createMandate(params, options) {
+        return this.http.post('/v1/notarize/mandates', params, options);
+    }
+    // --- Either party: get mandate metadata ---
+    async getMandate(id, options) {
+        return this.http.get(`/v1/notarize/mandates/${id}`, undefined, options);
+    }
+    // --- Either party: get transition history ---
+    async getHistory(id, options) {
+        return this.http.get(`/v1/notarize/mandates/${id}/history`, undefined, options);
+    }
+    // --- Performer: accept mandate ---
+    async acceptMandate(id, options) {
+        return this.http.post(`/v1/notarize/mandates/${id}/accept`, undefined, options);
+    }
+    // --- Performer: counter-propose ---
+    async counterPropose(id, params, options) {
+        return this.http.post(`/v1/notarize/mandates/${id}/counter-propose`, params, options);
+    }
+    // --- Performer: submit receipt ---
+    async submitReceipt(id, params, options) {
+        return this.http.post(`/v1/notarize/mandates/${id}/receipts`, params, options);
+    }
+    // --- Principal: render verdict ---
+    async renderVerdict(id, params, options) {
+        return this.http.post(`/v1/notarize/mandates/${id}/verdict`, params, options);
+    }
+    // --- Any party: verify a local copy matches the notarized hash ---
+    async verify(params, options) {
+        return this.http.post('/v1/notarize/verify', params, options);
+    }
+}
+//# sourceMappingURL=notarize.js.map

package/dist/resources/proxy.d.ts

@@ -0,0 +1,74 @@
+/**
+ * AGLedger™ SDK — Governance Sidecar Proxy Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ *
+ * Decomposed into sub-resources for sessions, tool calls, sidecar mandates,
+ * sidecar receipts, tool catalog, and analytics.
+ */
+import type { HttpClient } from '../http.js';
+import type { ProxySession, CreateSessionParams, SyncSessionParams, SyncSessionResult, ToolCallBatchItem, SidecarMandateBatchItem, SidecarReceiptBatchItem, ToolCatalogBatchItem, ProxySidecarMandate, ProxySidecarReceipt, ProxyToolCall, ProxyToolCatalogEntry, UpdateSidecarMandateParams, SessionAnalytics, AnalyticsSummary, MandateSummary, AlignmentAnalysis, BatchResult, Page, ListParams, RequestOptions } from '../types.js';
+export declare class ProxySessionsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    create(params: CreateSessionParams, options?: RequestOptions): Promise<ProxySession>;
+    get(sessionId: string, options?: RequestOptions): Promise<ProxySession>;
+    list(params?: ListParams, options?: RequestOptions): Promise<Page<ProxySession>>;
+    /**
+     * Unified sync: session + tool calls + sidecar mandates + sidecar receipts + tool catalog
+     * in a single request. Returns mandateIdMap mapping local SM-xxx IDs to backend UUIDs.
+     */
+    sync(params: SyncSessionParams, options?: RequestOptions): Promise<SyncSessionResult>;
+}
+export declare class ProxyToolCallsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    ingest(sessionId: string, items: ToolCallBatchItem[], options?: RequestOptions): Promise<BatchResult<ProxyToolCall>>;
+    list(sessionId: string, params?: ListParams, options?: RequestOptions): Promise<Page<ProxyToolCall>>;
+}
+export declare class ProxySidecarMandatesResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    ingest(sessionId: string, items: SidecarMandateBatchItem[], options?: RequestOptions): Promise<BatchResult<ProxySidecarMandate>>;
+    list(params?: ListParams & {
+        sessionId?: string;
+    }, options?: RequestOptions): Promise<Page<ProxySidecarMandate>>;
+    listBySession(sessionId: string, params?: ListParams, options?: RequestOptions): Promise<Page<ProxySidecarMandate>>;
+    update(id: string, params: UpdateSidecarMandateParams, options?: RequestOptions): Promise<ProxySidecarMandate>;
+    formalize(id: string, formalizedMandateId: string, options?: RequestOptions): Promise<ProxySidecarMandate>;
+    dismiss(id: string, options?: RequestOptions): Promise<ProxySidecarMandate>;
+}
+export declare class ProxySidecarReceiptsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    ingest(sessionId: string, items: SidecarReceiptBatchItem[], options?: RequestOptions): Promise<BatchResult<ProxySidecarReceipt>>;
+    listBySession(sessionId: string, params?: ListParams, options?: RequestOptions): Promise<Page<ProxySidecarReceipt>>;
+}
+export declare class ProxyToolCatalogResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    ingest(sessionId: string, items: ToolCatalogBatchItem[], options?: RequestOptions): Promise<BatchResult<ProxyToolCatalogEntry>>;
+    list(sessionId: string, options?: RequestOptions): Promise<Page<ProxyToolCatalogEntry>>;
+}
+export declare class ProxyAnalyticsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    getSession(sessionId: string, options?: RequestOptions): Promise<SessionAnalytics>;
+    getSummary(params?: {
+        from?: string;
+        to?: string;
+    }, options?: RequestOptions): Promise<AnalyticsSummary>;
+    getMandateSummary(sessionId: string, options?: RequestOptions): Promise<MandateSummary>;
+    getAlignment(sessionId: string, options?: RequestOptions): Promise<AlignmentAnalysis>;
+}
+export declare class ProxyResource {
+    readonly sessions: ProxySessionsResource;
+    readonly toolCalls: ProxyToolCallsResource;
+    readonly sidecarMandates: ProxySidecarMandatesResource;
+    readonly sidecarReceipts: ProxySidecarReceiptsResource;
+    readonly toolCatalog: ProxyToolCatalogResource;
+    readonly analytics: ProxyAnalyticsResource;
+    constructor(http: HttpClient);
+    /** Convenience: unified sync (delegates to sessions.sync). */
+    syncSession(params: SyncSessionParams, options?: RequestOptions): Promise<SyncSessionResult>;
+}
+//# sourceMappingURL=proxy.d.ts.map

package/dist/resources/proxy.js

@@ -0,0 +1,149 @@
+/**
+ * AGLedger™ SDK — Governance Sidecar Proxy Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ *
+ * Decomposed into sub-resources for sessions, tool calls, sidecar mandates,
+ * sidecar receipts, tool catalog, and analytics.
+ */
+// ---------------------------------------------------------------------------
+// Sessions
+// ---------------------------------------------------------------------------
+export class ProxySessionsResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async create(params, options) {
+        return this.http.post('/v1/proxy/sessions', params, options);
+    }
+    async get(sessionId, options) {
+        return this.http.get(`/v1/proxy/sessions/${sessionId}`, undefined, options);
+    }
+    async list(params, options) {
+        return this.http.getPage('/v1/proxy/sessions', params, options);
+    }
+    /**
+     * Unified sync: session + tool calls + sidecar mandates + sidecar receipts + tool catalog
+     * in a single request. Returns mandateIdMap mapping local SM-xxx IDs to backend UUIDs.
+     */
+    async sync(params, options) {
+        return this.http.post('/v1/proxy/sync', params, { ...options, timeout: options?.timeout ?? 60_000 });
+    }
+}
+// ---------------------------------------------------------------------------
+// Tool Calls
+// ---------------------------------------------------------------------------
+export class ProxyToolCallsResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async ingest(sessionId, items, options) {
+        return this.http.post(`/v1/proxy/sessions/${sessionId}/tool-calls`, { items }, options);
+    }
+    async list(sessionId, params, options) {
+        return this.http.getPage(`/v1/proxy/sessions/${sessionId}/tool-calls`, params, options);
+    }
+}
+// ---------------------------------------------------------------------------
+// Sidecar Mandates
+// ---------------------------------------------------------------------------
+export class ProxySidecarMandatesResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async ingest(sessionId, items, options) {
+        return this.http.post(`/v1/proxy/sessions/${sessionId}/sidecar-mandates`, { items }, options);
+    }
+    async list(params, options) {
+        return this.http.getPage('/v1/proxy/sidecar-mandates', params, options);
+    }
+    async listBySession(sessionId, params, options) {
+        return this.http.getPage(`/v1/proxy/sessions/${sessionId}/sidecar-mandates`, params, options);
+    }
+    async update(id, params, options) {
+        return this.http.patch(`/v1/proxy/sidecar-mandates/${id}`, params, options);
+    }
+    async formalize(id, formalizedMandateId, options) {
+        return this.update(id, { status: 'FORMALIZED', formalizedMandateId }, options);
+    }
+    async dismiss(id, options) {
+        return this.update(id, { status: 'DISMISSED' }, options);
+    }
+}
+// ---------------------------------------------------------------------------
+// Sidecar Receipts
+// ---------------------------------------------------------------------------
+export class ProxySidecarReceiptsResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async ingest(sessionId, items, options) {
+        return this.http.post(`/v1/proxy/sessions/${sessionId}/sidecar-receipts`, { items }, options);
+    }
+    async listBySession(sessionId, params, options) {
+        return this.http.getPage(`/v1/proxy/sessions/${sessionId}/sidecar-receipts`, params, options);
+    }
+}
+// ---------------------------------------------------------------------------
+// Tool Catalog
+// ---------------------------------------------------------------------------
+export class ProxyToolCatalogResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async ingest(sessionId, items, options) {
+        return this.http.post(`/v1/proxy/sessions/${sessionId}/tool-catalog`, { items }, options);
+    }
+    async list(sessionId, options) {
+        return this.http.getPage(`/v1/proxy/sessions/${sessionId}/tool-catalog`, undefined, options);
+    }
+}
+// ---------------------------------------------------------------------------
+// Analytics
+// ---------------------------------------------------------------------------
+export class ProxyAnalyticsResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async getSession(sessionId, options) {
+        return this.http.get(`/v1/proxy/sessions/${sessionId}/analytics`, undefined, options);
+    }
+    async getSummary(params, options) {
+        return this.http.get('/v1/proxy/analytics', params, options);
+    }
+    async getMandateSummary(sessionId, options) {
+        return this.http.get(`/v1/proxy/sessions/${sessionId}/mandate-summary`, undefined, options);
+    }
+    async getAlignment(sessionId, options) {
+        return this.http.get(`/v1/proxy/sessions/${sessionId}/alignment`, undefined, options);
+    }
+}
+// ---------------------------------------------------------------------------
+// Unified Proxy Resource
+// ---------------------------------------------------------------------------
+export class ProxyResource {
+    sessions;
+    toolCalls;
+    sidecarMandates;
+    sidecarReceipts;
+    toolCatalog;
+    analytics;
+    constructor(http) {
+        this.sessions = new ProxySessionsResource(http);
+        this.toolCalls = new ProxyToolCallsResource(http);
+        this.sidecarMandates = new ProxySidecarMandatesResource(http);
+        this.sidecarReceipts = new ProxySidecarReceiptsResource(http);
+        this.toolCatalog = new ProxyToolCatalogResource(http);
+        this.analytics = new ProxyAnalyticsResource(http);
+    }
+    /** Convenience: unified sync (delegates to sessions.sync). */
+    async syncSession(params, options) {
+        return this.sessions.sync(params, options);
+    }
+}
+//# sourceMappingURL=proxy.js.map

package/dist/resources/receipts.d.ts

@@ -0,0 +1,28 @@
+/**
+ * AGLedger™ SDK — Receipts Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ */
+import type { HttpClient } from '../http.js';
+import type { Receipt, SubmitReceiptParams, UpdateReceiptParams, Page, ListParams, RequestOptions, AutoPaginateOptions, TypedSubmitReceiptParams } from '../types.js';
+export declare class ReceiptsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Submit a receipt. When the mandate's contract type is known,
+     * pass a generic to get typed `evidence` fields.
+     *
+     * @example
+     * client.receipts.submit<'ACH-DATA-v1'>(mandateId, {
+     *   agentId: 'agent-1',
+     *   evidence: { deliverable: '/out.parquet', deliverable_type: 'file_ref', row_count: 50000 },
+     * });
+     */
+    submit<T extends string>(mandateId: string, params: TypedSubmitReceiptParams<T>, options?: RequestOptions): Promise<Receipt>;
+    submit(mandateId: string, params: SubmitReceiptParams, options?: RequestOptions): Promise<Receipt>;
+    get(mandateId: string, receiptId: string, options?: RequestOptions): Promise<Receipt>;
+    list(mandateId: string, params?: ListParams, options?: RequestOptions): Promise<Page<Receipt>>;
+    /** Auto-paginating iterator. Yields individual receipts. */
+    listAll(mandateId: string, params?: ListParams, options?: RequestOptions & AutoPaginateOptions): AsyncGenerator<Receipt>;
+    update(mandateId: string, receiptId: string, params: UpdateReceiptParams, options?: RequestOptions): Promise<Receipt>;
+}
+//# sourceMappingURL=receipts.d.ts.map

package/dist/resources/receipts.js

@@ -0,0 +1,27 @@
+/**
+ * AGLedger™ SDK — Receipts Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ */
+export class ReceiptsResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async submit(mandateId, params, options) {
+        return this.http.post(`/v1/mandates/${mandateId}/receipts`, params, options);
+    }
+    async get(mandateId, receiptId, options) {
+        return this.http.get(`/v1/mandates/${mandateId}/receipts/${receiptId}`, undefined, options);
+    }
+    async list(mandateId, params, options) {
+        return this.http.getPage(`/v1/mandates/${mandateId}/receipts`, params, options);
+    }
+    /** Auto-paginating iterator. Yields individual receipts. */
+    listAll(mandateId, params, options) {
+        return this.http.paginate(`/v1/mandates/${mandateId}/receipts`, params, options);
+    }
+    async update(mandateId, receiptId, params, options) {
+        return this.http.patch(`/v1/mandates/${mandateId}/receipts/${receiptId}`, params, options);
+    }
+}
+//# sourceMappingURL=receipts.js.map

package/dist/resources/registration.d.ts

@@ -0,0 +1,30 @@
+/**
+ * AGLedger™ SDK — Registration & Auth Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ */
+import type { HttpClient } from '../http.js';
+import type { RegisterParams, RegisterResult, AccountProfile, RequestOptions } from '../types.js';
+export declare class RegistrationResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** Get the authenticated account profile. */
+    getMe(options?: RequestOptions): Promise<AccountProfile>;
+    /** Register a new account (enterprise or agent). */
+    register(params: RegisterParams, options?: RequestOptions): Promise<RegisterResult>;
+    /** Register an enterprise account. */
+    registerEnterprise(params: Record<string, unknown>, options?: RequestOptions): Promise<RegisterResult>;
+    /** Register an agent account. */
+    registerAgent(params: Record<string, unknown>, options?: RequestOptions): Promise<RegisterResult>;
+    /** Verify an agent via A2A AgentCard URL. */
+    verifyAgentCard(agentCardUrl: string, options?: RequestOptions): Promise<Record<string, unknown>>;
+    /** Rotate the current API key. Old key is immediately revoked. */
+    rotateApiKey(options?: RequestOptions): Promise<{
+        apiKey: string;
+    }>;
+    /** Verify email address with token. */
+    verifyEmail(token: string, options?: RequestOptions): Promise<{
+        sandboxMode: boolean;
+        status: string;
+    }>;
+}
+//# sourceMappingURL=registration.d.ts.map