@agledger/sdk 1.1.0 → 2.0.0

package/dist/resources/enterprises.js

@@ -0,0 +1,43 @@
+/**
+ * AGLedger™ SDK — Enterprises Resource (Agent Approval Registry)
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ */
+export class EnterprisesResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /** Approve an agent for an enterprise (idempotent PUT). */
+    async approveAgent(enterpriseId, agentId, params, options) {
+        return this.http.put(`/v1/enterprises/${enterpriseId}/agents/${agentId}`, params, options);
+    }
+    /** Revoke an agent's approval for an enterprise. */
+    async revokeAgent(enterpriseId, agentId, params, options) {
+        return this.http.delete(`/v1/enterprises/${enterpriseId}/agents/${agentId}`, params, options);
+    }
+    /** Update an agent's status (e.g., suspend or reactivate). */
+    async updateAgentStatus(enterpriseId, agentId, params, options) {
+        return this.http.patch(`/v1/enterprises/${enterpriseId}/agents/${agentId}`, params, options);
+    }
+    /** Approve multiple agents at once. */
+    async bulkApprove(enterpriseId, params, options) {
+        return this.http.post(`/v1/enterprises/${enterpriseId}/agents/bulk`, params, options);
+    }
+    /** List agents for an enterprise, optionally filtered by status. */
+    async listAgents(enterpriseId, params, options) {
+        return this.http.getPage(`/v1/enterprises/${enterpriseId}/agents`, params, options);
+    }
+    /** Get a single agent's approval record. */
+    async getAgent(enterpriseId, agentId, options) {
+        return this.http.get(`/v1/enterprises/${enterpriseId}/agents/${agentId}`, undefined, options);
+    }
+    /** Get the enterprise's agent approval configuration. */
+    async getApprovalConfig(enterpriseId, options) {
+        return this.http.get(`/v1/enterprises/${enterpriseId}/approval-config`, undefined, options);
+    }
+    /** Set the enterprise's agent approval configuration. */
+    async setApprovalConfig(enterpriseId, params, options) {
+        return this.http.put(`/v1/enterprises/${enterpriseId}/approval-config`, params, options);
+    }
+}
+//# sourceMappingURL=enterprises.js.map

package/dist/resources/events.d.ts

@@ -3,7 +3,7 @@
  * 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';
+import type { AgledgerEvent, AuditChain, Page, ListParams, RequestOptions, AutoPaginateOptions } from '../types.js';
 export declare class EventsResource {
     private readonly http;
     constructor(http: HttpClient);
@@ -15,6 +15,11 @@ export declare class EventsResource {
         since: string;
         order?: 'asc' | 'desc';
     } & ListParams, options?: RequestOptions): Promise<Page<AgledgerEvent>>;
+    /** Auto-paginating iterator. Yields individual events across all pages. */
+    listAll(params: {
+        since: string;
+        order?: 'asc' | 'desc';
+    } & ListParams, options?: RequestOptions & AutoPaginateOptions): AsyncGenerator<AgledgerEvent>;
     /** Get the hash-chained audit trail for a mandate. */
     getAuditChain(mandateId: string, options?: RequestOptions): Promise<AuditChain>;
 }

package/dist/resources/events.js

@@ -14,6 +14,10 @@ export class EventsResource {
     async list(params, options) {
         return this.http.getPage('/v1/events', params, options);
     }
+    /** Auto-paginating iterator. Yields individual events across all pages. */
+    listAll(params, options) {
+        return this.http.paginate('/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);

package/dist/resources/health.d.ts

@@ -7,7 +7,9 @@ import type { HealthResponse, StatusResponse, ConformanceResponse, RequestOption
 export declare class HealthResource {
     private readonly http;
     constructor(http: HttpClient);
+    /** Quick health check (GET /health). */
     check(options?: RequestOptions): Promise<HealthResponse>;
+    /** Get detailed system status with component health (GET /status). */
     status(options?: RequestOptions): Promise<StatusResponse>;
     /** Get platform conformance info (protocol version, features, limits). */
     conformance(options?: RequestOptions): Promise<ConformanceResponse>;

package/dist/resources/health.js

@@ -7,9 +7,11 @@ export class HealthResource {
     constructor(http) {
         this.http = http;
     }
+    /** Quick health check (GET /health). */
     async check(options) {
         return this.http.get('/health', undefined, options);
     }
+    /** Get detailed system status with component health (GET /status). */
     async status(options) {
         return this.http.get('/status', undefined, options);
     }

package/dist/resources/mandates.d.ts

@@ -15,13 +15,19 @@ export declare class MandatesResource {
     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 a mandate by ID. */
     get(id: string, options?: RequestOptions): Promise<Mandate>;
+    /** List mandates with optional filters. */
     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 mandates with advanced filters (status, contract type, date range). */
     search(params: SearchMandatesParams, options?: RequestOptions): Promise<Page<Mandate>>;
+    /** Update a mandate's mutable fields. */
     update(id: string, params: UpdateMandateParams, options?: RequestOptions): Promise<Mandate>;
+    /** Transition a mandate to a new state (register, activate, settle, cancel, refund). */
     transition(id: string, action: MandateTransitionAction, reason?: string, options?: RequestOptions): Promise<Mandate>;
+    /** Cancel a mandate with an optional reason. */
     cancel(id: string, reason?: string, options?: RequestOptions): Promise<Mandate>;
     /** Accept a PROPOSED mandate (as performer). */
     accept(id: string, options?: RequestOptions): Promise<Mandate>;
@@ -37,6 +43,7 @@ export declare class MandatesResource {
     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>;
+    /** Create multiple mandates in a single request. */
     bulkCreate(mandates: CreateMandateParams[], options?: RequestOptions): Promise<BulkCreateResult>;
     /** Get audit trail for a mandate. */
     getAudit(id: string, options?: RequestOptions): Promise<Record<string, unknown>>;
@@ -44,5 +51,11 @@ export declare class MandatesResource {
     listAsPrincipal(options?: RequestOptions): Promise<Page<Mandate>>;
     /** List mandates proposed to the authenticated agent. */
     listProposals(options?: RequestOptions): Promise<Page<Mandate>>;
+    /** Request revision after principal rejection (rework loop). Principal only. */
+    requestRevision(id: string, reason?: string, options?: RequestOptions): Promise<Mandate>;
+    /** Create a mandate and immediately activate it. Three API calls (create → register → activate) — if a step fails, the mandate ID is in the error. */
+    createAndActivate(params: CreateMandateParams, options?: RequestOptions): Promise<Mandate>;
+    /** Get valid transitions for a mandate's current status. Client-side lookup, no API call. */
+    getValidTransitions(mandate: Mandate): readonly string[];
 }
 //# sourceMappingURL=mandates.d.ts.map

package/dist/resources/mandates.js

@@ -2,6 +2,7 @@
  * AGLedger™ SDK — Mandates Resource
  * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
  */
+import { getValidTransitions as getTransitions } from '../mandate-lifecycle.js';
 export class MandatesResource {
     http;
     constructor(http) {
@@ -14,9 +15,11 @@ export class MandatesResource {
     async createAgent(params, options) {
         return this.http.post('/v1/mandates/agent', params, options);
     }
+    /** Get a mandate by ID. */
     async get(id, options) {
         return this.http.get(`/v1/mandates/${id}`, undefined, options);
     }
+    /** List mandates with optional filters. */
     async list(params, options) {
         return this.http.getPage('/v1/mandates', params, options);
     }
@@ -24,28 +27,32 @@ export class MandatesResource {
     listAll(params, options) {
         return this.http.paginate('/v1/mandates', params, options);
     }
+    /** Search mandates with advanced filters (status, contract type, date range). */
     async search(params, options) {
         return this.http.getPage('/v1/mandates/search', params, options);
     }
+    /** Update a mandate's mutable fields. */
     async update(id, params, options) {
         return this.http.patch(`/v1/mandates/${id}`, params, options);
     }
+    /** Transition a mandate to a new state (register, activate, settle, cancel, refund). */
     async transition(id, action, reason, options) {
         const body = { action };
         if (reason)
             body.reason = reason;
         return this.http.post(`/v1/mandates/${id}/transition`, body, options);
     }
+    /** Cancel a mandate with an optional reason. */
     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);
+        return this.http.post(`/v1/mandates/${id}/accept`, {}, options);
     }
     /** Reject a PROPOSED mandate (as performer). */
     async reject(id, reason, options) {
-        return this.http.post(`/v1/mandates/${id}/reject`, reason ? { reason } : undefined, options);
+        return this.http.post(`/v1/mandates/${id}/reject`, reason ? { reason } : {}, options);
     }
     /** Respond to a PROPOSED mandate (accept, reject, or counter). */
     async respond(id, params, options) {
@@ -53,7 +60,7 @@ export class MandatesResource {
     }
     /** Accept a counter-proposal on a mandate. */
     async acceptCounter(id, options) {
-        return this.http.post(`/v1/mandates/${id}/accept-counter`, undefined, options);
+        return this.http.post(`/v1/mandates/${id}/accept-counter`, {}, options);
     }
     /** Get the full delegation chain for a mandate. */
     async getChain(id, options) {
@@ -70,6 +77,7 @@ export class MandatesResource {
             parentMandateId: id,
         }, options);
     }
+    /** Create multiple mandates in a single request. */
     async bulkCreate(mandates, options) {
         return this.http.post('/v1/mandates/bulk', { mandates }, options);
     }
@@ -85,5 +93,19 @@ export class MandatesResource {
     async listProposals(options) {
         return this.http.getPage('/v1/mandates/agent/proposals', undefined, options);
     }
+    /** Request revision after principal rejection (rework loop). Principal only. */
+    async requestRevision(id, reason, options) {
+        return this.http.post(`/v1/mandates/${id}/revision`, reason ? { reason } : {}, options);
+    }
+    /** Create a mandate and immediately activate it. Three API calls (create → register → activate) — if a step fails, the mandate ID is in the error. */
+    async createAndActivate(params, options) {
+        const mandate = await this.create(params, options);
+        await this.transition(mandate.id, 'register', undefined, options);
+        return this.transition(mandate.id, 'activate', undefined, options);
+    }
+    /** Get valid transitions for a mandate's current status. Client-side lookup, no API call. */
+    getValidTransitions(mandate) {
+        return getTransitions(mandate.status);
+    }
 }
 //# sourceMappingURL=mandates.js.map

package/dist/resources/notarize.d.ts

@@ -8,13 +8,21 @@ import type { NotarizedMandate, NotarizeMandateParams, NotarizeMandateResult, No
 export declare class NotarizeResource {
     private readonly http;
     constructor(http: HttpClient);
+    /** Create a notarized mandate (principal action). */
     createMandate(params: NotarizeMandateParams, options?: RequestOptions): Promise<NotarizeMandateResult>;
+    /** Get a notarized mandate by ID. */
     getMandate(id: string, options?: RequestOptions): Promise<NotarizedMandate>;
+    /** Get the transition history for a notarized mandate. */
     getHistory(id: string, options?: RequestOptions): Promise<NotarizeHistory>;
+    /** Accept a notarized mandate (performer action). */
     acceptMandate(id: string, options?: RequestOptions): Promise<NotarizedMandate>;
+    /** Counter-propose new terms for a notarized mandate (performer action). */
     counterPropose(id: string, params: NotarizeCounterProposeParams, options?: RequestOptions): Promise<NotarizeMandateResult>;
+    /** Submit a receipt against a notarized mandate (performer action). */
     submitReceipt(id: string, params: NotarizeReceiptParams, options?: RequestOptions): Promise<NotarizeReceiptResult>;
+    /** Render a verdict on a notarized mandate (principal action). */
     renderVerdict(id: string, params: NotarizeVerdictParams, options?: RequestOptions): Promise<NotarizedMandate>;
+    /** Verify that a local copy matches the notarized hash. */
     verify(params: NotarizeVerifyParams, options?: RequestOptions): Promise<NotarizeVerifyResult>;
 }
 //# sourceMappingURL=notarize.d.ts.map

package/dist/resources/notarize.js

@@ -8,35 +8,35 @@ export class NotarizeResource {
     constructor(http) {
         this.http = http;
     }
-    // --- Principal: create a notarized mandate ---
+    /** Create a notarized mandate (principal action). */
     async createMandate(params, options) {
         return this.http.post('/v1/notarize/mandates', params, options);
     }
-    // --- Either party: get mandate metadata ---
+    /** Get a notarized mandate by ID. */
     async getMandate(id, options) {
         return this.http.get(`/v1/notarize/mandates/${id}`, undefined, options);
     }
-    // --- Either party: get transition history ---
+    /** Get the transition history for a notarized mandate. */
     async getHistory(id, options) {
         return this.http.get(`/v1/notarize/mandates/${id}/history`, undefined, options);
     }
-    // --- Performer: accept mandate ---
+    /** Accept a notarized mandate (performer action). */
     async acceptMandate(id, options) {
         return this.http.post(`/v1/notarize/mandates/${id}/accept`, undefined, options);
     }
-    // --- Performer: counter-propose ---
+    /** Counter-propose new terms for a notarized mandate (performer action). */
     async counterPropose(id, params, options) {
         return this.http.post(`/v1/notarize/mandates/${id}/counter-propose`, params, options);
     }
-    // --- Performer: submit receipt ---
+    /** Submit a receipt against a notarized mandate (performer action). */
     async submitReceipt(id, params, options) {
         return this.http.post(`/v1/notarize/mandates/${id}/receipts`, params, options);
     }
-    // --- Principal: render verdict ---
+    /** Render a verdict on a notarized mandate (principal action). */
     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 ---
+    /** Verify that a local copy matches the notarized hash. */
     async verify(params, options) {
         return this.http.post('/v1/notarize/verify', params, options);
     }

package/dist/resources/proxy.d.ts

@@ -10,54 +10,70 @@ import type { ProxySession, CreateSessionParams, SyncSessionParams, SyncSessionR
 export declare class ProxySessionsResource {
     private readonly http;
     constructor(http: HttpClient);
+    /** Create a new proxy session. */
     create(params: CreateSessionParams, options?: RequestOptions): Promise<ProxySession>;
+    /** Get a proxy session by ID. */
     get(sessionId: string, options?: RequestOptions): Promise<ProxySession>;
+    /** List proxy sessions. */
     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.
-     */
+    /** Unified sync: session + tool calls + sidecar mandates + sidecar receipts + tool catalog in a single request. */
     sync(params: SyncSessionParams, options?: RequestOptions): Promise<SyncSessionResult>;
 }
 export declare class ProxyToolCallsResource {
     private readonly http;
     constructor(http: HttpClient);
+    /** Ingest a batch of tool calls for a session. */
     ingest(sessionId: string, items: ToolCallBatchItem[], options?: RequestOptions): Promise<BatchResult<ProxyToolCall>>;
+    /** List tool calls for a session. */
     list(sessionId: string, params?: ListParams, options?: RequestOptions): Promise<Page<ProxyToolCall>>;
 }
 export declare class ProxySidecarMandatesResource {
     private readonly http;
     constructor(http: HttpClient);
+    /** Ingest a batch of sidecar mandates for a session. */
     ingest(sessionId: string, items: SidecarMandateBatchItem[], options?: RequestOptions): Promise<BatchResult<ProxySidecarMandate>>;
+    /** List sidecar mandates across sessions, optionally filtered by sessionId. */
     list(params?: ListParams & {
         sessionId?: string;
     }, options?: RequestOptions): Promise<Page<ProxySidecarMandate>>;
+    /** List sidecar mandates for a specific session. */
     listBySession(sessionId: string, params?: ListParams, options?: RequestOptions): Promise<Page<ProxySidecarMandate>>;
+    /** Update a sidecar mandate (e.g., formalize or dismiss). */
     update(id: string, params: UpdateSidecarMandateParams, options?: RequestOptions): Promise<ProxySidecarMandate>;
+    /** Formalize a sidecar mandate by linking it to a backend mandate ID. */
     formalize(id: string, formalizedMandateId: string, options?: RequestOptions): Promise<ProxySidecarMandate>;
+    /** Dismiss a sidecar mandate (mark as not actionable). */
     dismiss(id: string, options?: RequestOptions): Promise<ProxySidecarMandate>;
 }
 export declare class ProxySidecarReceiptsResource {
     private readonly http;
     constructor(http: HttpClient);
+    /** Ingest a batch of sidecar receipts for a session. */
     ingest(sessionId: string, items: SidecarReceiptBatchItem[], options?: RequestOptions): Promise<BatchResult<ProxySidecarReceipt>>;
+    /** List sidecar receipts for a specific session. */
     listBySession(sessionId: string, params?: ListParams, options?: RequestOptions): Promise<Page<ProxySidecarReceipt>>;
 }
 export declare class ProxyToolCatalogResource {
     private readonly http;
     constructor(http: HttpClient);
+    /** Ingest a batch of tool catalog entries for a session. */
     ingest(sessionId: string, items: ToolCatalogBatchItem[], options?: RequestOptions): Promise<BatchResult<ProxyToolCatalogEntry>>;
+    /** List tool catalog entries for a session. */
     list(sessionId: string, options?: RequestOptions): Promise<Page<ProxyToolCatalogEntry>>;
 }
 export declare class ProxyAnalyticsResource {
     private readonly http;
     constructor(http: HttpClient);
+    /** Get analytics for a specific session. */
     getSession(sessionId: string, options?: RequestOptions): Promise<SessionAnalytics>;
+    /** Get aggregated analytics summary across sessions. */
     getSummary(params?: {
         from?: string;
         to?: string;
     }, options?: RequestOptions): Promise<AnalyticsSummary>;
+    /** Get mandate summary for a session (detected vs formalized counts). */
     getMandateSummary(sessionId: string, options?: RequestOptions): Promise<MandateSummary>;
+    /** Get alignment analysis for a session (coverage gaps, missing categories). */
     getAlignment(sessionId: string, options?: RequestOptions): Promise<AlignmentAnalysis>;
 }
 export declare class ProxyResource {

package/dist/resources/proxy.js

@@ -13,19 +13,19 @@ export class ProxySessionsResource {
     constructor(http) {
         this.http = http;
     }
+    /** Create a new proxy session. */
     async create(params, options) {
         return this.http.post('/v1/proxy/sessions', params, options);
     }
+    /** Get a proxy session by ID. */
     async get(sessionId, options) {
         return this.http.get(`/v1/proxy/sessions/${sessionId}`, undefined, options);
     }
+    /** List proxy sessions. */
     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.
-     */
+    /** Unified sync: session + tool calls + sidecar mandates + sidecar receipts + tool catalog in a single request. */
     async sync(params, options) {
         return this.http.post('/v1/proxy/sync', params, { ...options, timeout: options?.timeout ?? 60_000 });
     }
@@ -38,9 +38,11 @@ export class ProxyToolCallsResource {
     constructor(http) {
         this.http = http;
     }
+    /** Ingest a batch of tool calls for a session. */
     async ingest(sessionId, items, options) {
         return this.http.post(`/v1/proxy/sessions/${sessionId}/tool-calls`, { items }, options);
     }
+    /** List tool calls for a session. */
     async list(sessionId, params, options) {
         return this.http.getPage(`/v1/proxy/sessions/${sessionId}/tool-calls`, params, options);
     }
@@ -53,21 +55,27 @@ export class ProxySidecarMandatesResource {
     constructor(http) {
         this.http = http;
     }
+    /** Ingest a batch of sidecar mandates for a session. */
     async ingest(sessionId, items, options) {
         return this.http.post(`/v1/proxy/sessions/${sessionId}/sidecar-mandates`, { items }, options);
     }
+    /** List sidecar mandates across sessions, optionally filtered by sessionId. */
     async list(params, options) {
         return this.http.getPage('/v1/proxy/sidecar-mandates', params, options);
     }
+    /** List sidecar mandates for a specific session. */
     async listBySession(sessionId, params, options) {
         return this.http.getPage(`/v1/proxy/sessions/${sessionId}/sidecar-mandates`, params, options);
     }
+    /** Update a sidecar mandate (e.g., formalize or dismiss). */
     async update(id, params, options) {
         return this.http.patch(`/v1/proxy/sidecar-mandates/${id}`, params, options);
     }
+    /** Formalize a sidecar mandate by linking it to a backend mandate ID. */
     async formalize(id, formalizedMandateId, options) {
         return this.update(id, { status: 'FORMALIZED', formalizedMandateId }, options);
     }
+    /** Dismiss a sidecar mandate (mark as not actionable). */
     async dismiss(id, options) {
         return this.update(id, { status: 'DISMISSED' }, options);
     }
@@ -80,9 +88,11 @@ export class ProxySidecarReceiptsResource {
     constructor(http) {
         this.http = http;
     }
+    /** Ingest a batch of sidecar receipts for a session. */
     async ingest(sessionId, items, options) {
         return this.http.post(`/v1/proxy/sessions/${sessionId}/sidecar-receipts`, { items }, options);
     }
+    /** List sidecar receipts for a specific session. */
     async listBySession(sessionId, params, options) {
         return this.http.getPage(`/v1/proxy/sessions/${sessionId}/sidecar-receipts`, params, options);
     }
@@ -95,9 +105,11 @@ export class ProxyToolCatalogResource {
     constructor(http) {
         this.http = http;
     }
+    /** Ingest a batch of tool catalog entries for a session. */
     async ingest(sessionId, items, options) {
         return this.http.post(`/v1/proxy/sessions/${sessionId}/tool-catalog`, { items }, options);
     }
+    /** List tool catalog entries for a session. */
     async list(sessionId, options) {
         return this.http.getPage(`/v1/proxy/sessions/${sessionId}/tool-catalog`, undefined, options);
     }
@@ -110,15 +122,19 @@ export class ProxyAnalyticsResource {
     constructor(http) {
         this.http = http;
     }
+    /** Get analytics for a specific session. */
     async getSession(sessionId, options) {
         return this.http.get(`/v1/proxy/sessions/${sessionId}/analytics`, undefined, options);
     }
+    /** Get aggregated analytics summary across sessions. */
     async getSummary(params, options) {
         return this.http.get('/v1/proxy/analytics', params, options);
     }
+    /** Get mandate summary for a session (detected vs formalized counts). */
     async getMandateSummary(sessionId, options) {
         return this.http.get(`/v1/proxy/sessions/${sessionId}/mandate-summary`, undefined, options);
     }
+    /** Get alignment analysis for a session (coverage gaps, missing categories). */
     async getAlignment(sessionId, options) {
         return this.http.get(`/v1/proxy/sessions/${sessionId}/alignment`, undefined, options);
     }

package/dist/resources/reputation.d.ts

@@ -7,7 +7,9 @@ import type { ReputationScore, ReputationHistoryEntry, Page, ListParams, Request
 export declare class ReputationResource {
     private readonly http;
     constructor(http: HttpClient);
+    /** Get the reputation score for an agent. */
     getAgent(agentId: string, options?: RequestOptions): Promise<ReputationScore>;
+    /** Get reputation score history for an agent over a time range. */
     getHistory(agentId: string, params?: ListParams & {
         from?: string;
         to?: string;

package/dist/resources/reputation.js

@@ -7,9 +7,11 @@ export class ReputationResource {
     constructor(http) {
         this.http = http;
     }
+    /** Get the reputation score for an agent. */
     async getAgent(agentId, options) {
         return this.http.get(`/v1/agents/${agentId}/reputation`, undefined, options);
     }
+    /** Get reputation score history for an agent over a time range. */
     async getHistory(agentId, params, options) {
         return this.http.getPage(`/v1/agents/${agentId}/reputation/history`, params, options);
     }

package/dist/resources/schemas.d.ts

@@ -7,8 +7,11 @@ import type { ContractType, ContractSchema, SchemaValidationResult, Page, Reques
 export declare class SchemasResource {
     private readonly http;
     constructor(http: HttpClient);
+    /** List available contract type schemas. */
     list(options?: RequestOptions): Promise<Page<ContractType>>;
+    /** Get the full JSON Schema for a contract type. */
     get(contractType: ContractType, options?: RequestOptions): Promise<ContractSchema>;
+    /** Get the verification rules for a contract type. */
     getRules(contractType: ContractType, options?: RequestOptions): Promise<{
         contractType: ContractType;
         syncRuleIds: string[];

package/dist/resources/schemas.js

@@ -7,12 +7,15 @@ export class SchemasResource {
     constructor(http) {
         this.http = http;
     }
+    /** List available contract type schemas. */
     async list(options) {
         return this.http.getPage('/v1/schemas', undefined, options);
     }
+    /** Get the full JSON Schema for a contract type. */
     async get(contractType, options) {
         return this.http.get(`/v1/schemas/${contractType}`, undefined, options);
     }
+    /** Get the verification rules for a contract type. */
     async getRules(contractType, options) {
         return this.http.get(`/v1/schemas/${contractType}/rules`, undefined, options);
     }

package/dist/resources/verification.d.ts

@@ -7,7 +7,9 @@ import type { VerificationResult, VerificationStatus, RequestOptions } from '../
 export declare class VerificationResource {
     private readonly http;
     constructor(http: HttpClient);
+    /** Trigger verification for a mandate, optionally specifying receipt IDs. */
     verify(mandateId: string, receiptIds?: string[], options?: RequestOptions): Promise<VerificationResult>;
+    /** Get the current verification status for a mandate. */
     getStatus(mandateId: string, options?: RequestOptions): Promise<VerificationStatus>;
 }
 //# sourceMappingURL=verification.d.ts.map

package/dist/resources/verification.js

@@ -7,9 +7,11 @@ export class VerificationResource {
     constructor(http) {
         this.http = http;
     }
+    /** Trigger verification for a mandate, optionally specifying receipt IDs. */
     async verify(mandateId, receiptIds, options) {
         return this.http.post(`/v1/mandates/${mandateId}/verify`, receiptIds?.length ? { receiptIds } : undefined, options);
     }
+    /** Get the current verification status for a mandate. */
     async getStatus(mandateId, options) {
         return this.http.get(`/v1/mandates/${mandateId}/verification-status`, undefined, options);
     }

package/dist/resources/webhooks.d.ts

@@ -7,10 +7,15 @@ import type { Webhook, CreateWebhookParams, UpdateWebhookParams, WebhookDelivery
 export declare class WebhooksResource {
     private readonly http;
     constructor(http: HttpClient);
+    /** Register a new webhook endpoint. */
     create(params: CreateWebhookParams, options?: RequestOptions): Promise<Webhook>;
+    /** Get a webhook by ID. */
     get(webhookId: string, options?: RequestOptions): Promise<Webhook>;
+    /** List all webhooks. */
     list(options?: RequestOptions): Promise<Page<Webhook>>;
+    /** Update a webhook's URL or event subscriptions. */
     update(webhookId: string, params: UpdateWebhookParams, options?: RequestOptions): Promise<Webhook>;
+    /** Delete a webhook. */
     delete(webhookId: string, options?: RequestOptions): Promise<void>;
     /** Rotate webhook secret. Returns new secret. */
     rotate(webhookId: string, options?: RequestOptions): Promise<{
@@ -18,6 +23,7 @@ export declare class WebhooksResource {
     }>;
     /** Send a test ping to the webhook URL. */
     ping(webhookId: string, options?: RequestOptions): Promise<WebhookTestResult>;
+    /** List delivery attempts for a webhook, optionally filtered by status. */
     listDeliveries(webhookId: string, params?: ListParams & {
         status?: string;
     }, options?: RequestOptions): Promise<Page<WebhookDelivery>>;

package/dist/resources/webhooks.js

@@ -7,20 +7,25 @@ export class WebhooksResource {
     constructor(http) {
         this.http = http;
     }
+    /** Register a new webhook endpoint. */
     async create(params, options) {
         return this.http.post('/v1/webhooks', params, options);
     }
+    /** Get a webhook by ID. */
     async get(webhookId, options) {
         return this.http.get(`/v1/webhooks/${webhookId}`, undefined, options);
     }
+    /** List all webhooks. */
     async list(options) {
         return this.http.getPage('/v1/webhooks', undefined, options);
     }
+    /** Update a webhook's URL or event subscriptions. */
     async update(webhookId, params, options) {
         return this.http.patch(`/v1/webhooks/${webhookId}`, params, options);
     }
+    /** Delete a webhook. */
     async delete(webhookId, options) {
-        return this.http.delete(`/v1/webhooks/${webhookId}`, options);
+        return this.http.delete(`/v1/webhooks/${webhookId}`, undefined, options);
     }
     /** Rotate webhook secret. Returns new secret. */
     async rotate(webhookId, options) {
@@ -30,6 +35,7 @@ export class WebhooksResource {
     async ping(webhookId, options) {
         return this.http.post(`/v1/webhooks/${webhookId}/ping`, undefined, options);
     }
+    /** List delivery attempts for a webhook, optionally filtered by status. */
     async listDeliveries(webhookId, params, options) {
         return this.http.getPage(`/v1/webhooks/${webhookId}/deliveries`, params, options);
     }