@agledger/sdk 1.1.0

package/dist/http.js

@@ -0,0 +1,272 @@
+/**
+ * AGLedger™ SDK — HTTP Client
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ *
+ * Zero runtime dependencies. Uses native fetch + crypto.
+ */
+import { AgledgerApiError, AuthenticationError, PermissionError, NotFoundError, ValidationError, UnprocessableError, RateLimitError, ConnectionError, TimeoutError, } from './errors.js';
+const BASE_URLS = {
+    production: 'https://api.agledger.ai',
+    sandbox: 'https://sandbox.api.agledger.ai',
+};
+const DEFAULT_BASE_URL = BASE_URLS.production;
+const DEFAULT_TIMEOUT = 30_000;
+const DEFAULT_MAX_RETRIES = 3;
+const MAX_BACKOFF = 30_000;
+export class HttpClient {
+    apiKey;
+    baseUrl;
+    maxRetries;
+    timeout;
+    fetchFn;
+    idempotencyKeyPrefix;
+    _rateLimitInfo = null;
+    /** Rate limit info from the most recent response. Null if headers not present. */
+    get rateLimitInfo() {
+        return this._rateLimitInfo;
+    }
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        const envUrl = options.environment ? BASE_URLS[options.environment] : undefined;
+        this.baseUrl = (options.baseUrl || envUrl || DEFAULT_BASE_URL).replace(/\/+$/, '');
+        this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+        this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+        this.fetchFn = options.fetch ?? globalThis.fetch.bind(globalThis);
+        this.idempotencyKeyPrefix = options.idempotencyKeyPrefix ?? '';
+    }
+    async get(path, params, options) {
+        const url = this.buildUrl(path, params);
+        return this.request('GET', url, undefined, options);
+    }
+    async post(path, body, options) {
+        const url = this.buildUrl(path);
+        return this.request('POST', url, body, options);
+    }
+    async patch(path, body, options) {
+        const url = this.buildUrl(path);
+        return this.request('PATCH', url, body, options);
+    }
+    async delete(path, options) {
+        const url = this.buildUrl(path);
+        return this.request('DELETE', url, undefined, options);
+    }
+    /**
+     * Fetch a list endpoint and normalize the response into Page<T>.
+     * Handles both current inconsistent responses (bare arrays, various envelope shapes)
+     * and the target format ({ data, hasMore, nextCursor, total }).
+     */
+    async getPage(path, params, options) {
+        const raw = await this.get(path, params, options);
+        return this.normalizePage(raw);
+    }
+    /**
+     * Async iterator for auto-paginating through all pages.
+     * Yields individual items. Stops after maxPages (default: 100) as a safety ceiling.
+     */
+    async *paginate(path, params, options) {
+        const maxPages = options?.maxPages ?? 100;
+        const maxItems = options?.maxItems;
+        let cursor;
+        let pagesRead = 0;
+        let itemsYielded = 0;
+        while (pagesRead < maxPages) {
+            const pageParams = { ...params, ...(cursor ? { cursor } : {}) };
+            const page = await this.getPage(path, pageParams, options);
+            pagesRead++;
+            for (const item of page.data) {
+                yield item;
+                itemsYielded++;
+                if (maxItems && itemsYielded >= maxItems)
+                    return;
+            }
+            if (!page.hasMore || !page.nextCursor)
+                return;
+            cursor = page.nextCursor;
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Internal
+    // ---------------------------------------------------------------------------
+    buildUrl(path, params) {
+        const raw = path.startsWith('/') ? `${this.baseUrl}${path}` : `${this.baseUrl}/${path}`;
+        const url = new URL(raw);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined && value !== null) {
+                    url.searchParams.set(key, String(value));
+                }
+            }
+        }
+        return url.toString();
+    }
+    async request(method, url, body, options) {
+        // Idempotency keys for all mutating methods
+        const needsIdempotencyKey = method === 'POST' || method === 'PATCH' || method === 'DELETE';
+        const idempotencyKey = options?.idempotencyKey ??
+            (needsIdempotencyKey
+                ? `${this.idempotencyKeyPrefix}${crypto.randomUUID()}`
+                : undefined);
+        let lastError;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            if (attempt > 0) {
+                await this.sleep(this.backoff(attempt, lastError));
+            }
+            const timeout = options?.timeout ?? this.timeout;
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeout);
+            if (options?.signal) {
+                if (options.signal.aborted) {
+                    clearTimeout(timer);
+                    throw new ConnectionError('Request aborted', new Error('AbortError'));
+                }
+                options.signal.addEventListener('abort', () => controller.abort(), { once: true });
+            }
+            const headers = {
+                Authorization: `Bearer ${this.apiKey}`,
+                Accept: 'application/json',
+            };
+            if (body !== undefined) {
+                headers['Content-Type'] = 'application/json';
+            }
+            if (idempotencyKey) {
+                headers['Idempotency-Key'] = idempotencyKey;
+            }
+            try {
+                const response = await this.fetchFn(url, {
+                    method,
+                    headers,
+                    body: body !== undefined ? JSON.stringify(body) : undefined,
+                    signal: controller.signal,
+                });
+                clearTimeout(timer);
+                if (response.status === 204) {
+                    return undefined;
+                }
+                this.parseRateLimitHeaders(response.headers);
+                if (response.ok) {
+                    return (await response.json());
+                }
+                // Parse error body
+                let errorBody;
+                try {
+                    errorBody = (await response.json());
+                }
+                catch {
+                    errorBody = {
+                        error: 'unknown',
+                        message: response.statusText || `HTTP ${response.status}`,
+                    };
+                }
+                const error = this.mapError(response.status, errorBody, response.headers);
+                // Retry on 429 and 5xx
+                if (response.status === 429 || response.status >= 500) {
+                    lastError = error;
+                    continue;
+                }
+                throw error;
+            }
+            catch (err) {
+                clearTimeout(timer);
+                if (err instanceof AgledgerApiError) {
+                    throw err;
+                }
+                const cause = err;
+                if (cause.name === 'AbortError') {
+                    lastError = new TimeoutError(method, url, timeout, cause);
+                }
+                else {
+                    lastError = new ConnectionError(`Network error: ${cause.message}`, cause);
+                }
+                // Retry network errors
+                continue;
+            }
+        }
+        throw lastError;
+    }
+    mapError(status, body, headers) {
+        const errorBody = {
+            error: body.error || 'unknown',
+            message: body.message || `HTTP ${status}`,
+            requestId: body.requestId,
+            code: body.code,
+            retryable: body.retryable,
+            details: body.details,
+        };
+        switch (status) {
+            case 400:
+                return new ValidationError(errorBody);
+            case 401:
+                return new AuthenticationError(errorBody);
+            case 403:
+                return new PermissionError(errorBody);
+            case 404:
+                return new NotFoundError(errorBody);
+            case 422:
+                return new UnprocessableError(errorBody);
+            case 429: {
+                const retryAfterHeader = headers.get('Retry-After');
+                const retryAfter = retryAfterHeader
+                    ? parseInt(retryAfterHeader, 10) * 1000
+                    : null;
+                return new RateLimitError(errorBody, retryAfter);
+            }
+            default:
+                return new AgledgerApiError(status, errorBody);
+        }
+    }
+    backoff(attempt, lastError) {
+        let delay = Math.min(1000 * Math.pow(2, attempt - 1), MAX_BACKOFF);
+        // Honor Retry-After from rate limit errors
+        if (lastError instanceof RateLimitError && lastError.retryAfter) {
+            delay = Math.max(delay, lastError.retryAfter);
+        }
+        // Add 0–25% jitter
+        const jitter = delay * Math.random() * 0.25;
+        return delay + jitter;
+    }
+    parseRateLimitHeaders(headers) {
+        const limit = headers.get('x-ratelimit-limit');
+        const remaining = headers.get('x-ratelimit-remaining');
+        const reset = headers.get('x-ratelimit-reset');
+        if (limit !== null && remaining !== null && reset !== null) {
+            this._rateLimitInfo = {
+                limit: parseInt(limit, 10),
+                remaining: parseInt(remaining, 10),
+                reset: parseInt(reset, 10),
+            };
+        }
+    }
+    /**
+     * Normalize any list response shape into Page<T>.
+     * Handles: bare array, { data }, { data, hasMore, nextCursor, total },
+     * { data, total, limit, offset }, { data, next_cursor }.
+     */
+    normalizePage(raw) {
+        // Bare array
+        if (Array.isArray(raw)) {
+            return { data: raw, hasMore: false };
+        }
+        const obj = raw;
+        const data = (Array.isArray(obj.data) ? obj.data : []);
+        const nextCursor = (obj.nextCursor || obj.next_cursor || null);
+        // Explicit hasMore from API
+        if (typeof obj.hasMore === 'boolean') {
+            return { data, hasMore: obj.hasMore, nextCursor, total: obj.total };
+        }
+        // Offset-based: infer hasMore from total/limit/offset
+        if (typeof obj.total === 'number' && typeof obj.limit === 'number' && typeof obj.offset === 'number') {
+            return {
+                data,
+                hasMore: obj.offset + obj.limit < obj.total,
+                nextCursor,
+                total: obj.total,
+            };
+        }
+        // Cursor-based: hasMore if cursor present
+        return { data, hasMore: !!nextCursor, nextCursor, total: obj.total };
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+//# sourceMappingURL=http.js.map

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * AGLedger™ SDK v1.0.0
+ * Accountability and audit infrastructure for agentic systems.
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ *
+ * @packageDocumentation
+ */
+export { AgledgerClient } from './client.js';
+export type { AgledgerClientOptions, RequestOptions, ListParams, Page, AutoPaginateOptions, BatchResult, BulkCreateResult, ContractType, ContractSchema, SchemaValidationResult, Denomination, ProcurementCriteria, DeliverableCriteria, DataProcessingCriteria, TransactionCriteria, OrchestrationCriteria, CommunicationCriteria, AuthorizationCriteria, InfrastructureCriteria, DestructiveCriteria, ProcurementEvidence, DeliverableEvidence, DataProcessingEvidence, TransactionEvidence, OrchestrationEvidence, CommunicationEvidence, AuthorizationEvidence, InfrastructureEvidence, DestructiveEvidence, CriteriaMap, EvidenceMap, CriteriaFor, EvidenceFor, TypedCreateMandateParams, TypedSubmitReceiptParams, MandateStatus, MandateTransitionAction, OperatingMode, RiskClassification, Mandate, CreateMandateParams, UpdateMandateParams, ListMandatesParams, SearchMandatesParams, DelegateMandateParams, CreateAgentMandateParams, RespondToMandateParams, ReceiptStatus, Receipt, SubmitReceiptParams, UpdateReceiptParams, VerificationOutcome, SettlementSignal, VerificationResult, VerificationStatus, DisputeStatus, Dispute, CreateDisputeParams, ResolveDisputeParams, WebhookEventType, Webhook, CreateWebhookParams, UpdateWebhookParams, WebhookDelivery, WebhookTestResult, ReputationTier, ReputationScore, ReputationHistoryEntry, AgledgerEvent, AuditChain, RateLimitInfo, DashboardSummary, DashboardMetrics, DashboardMetricsParams, DashboardAgent, DashboardAgentParams, ComplianceExport, ExportComplianceParams, AiImpactAssessment, CreateAiImpactAssessmentParams, EuAiActReport, AccountType, AccountProfile, RegisterParams, RegisterResult, HealthResponse, StatusComponent, StatusResponse, ConformanceResponse, AdminEnterprise, AdminAgent, AdminApiKey, WebhookDlqEntry, SystemHealth, UpdateTrustLevelParams, SetCapabilitiesParams, AgentCard, JsonRpcRequest, JsonRpcResponse, ProxyMode, InterceptorAction, ConfidenceLevel, SidecarMandateStatus, SessionOutcome, ProxySession, CreateSessionParams, ToolCallBatchItem, SidecarMandateBatchItem, SidecarReceiptBatchItem, ToolCatalogBatchItem, SyncSessionParams, SyncSessionResult, ProxySidecarMandate, ProxySidecarReceipt, ProxyToolCall, ProxyToolCatalogEntry, UpdateSidecarMandateParams, SessionAnalytics, AnalyticsSummary, MandateSummary, AlignmentAnalysis, NotarizeStatus, NotarizedMandate, NotarizeTransition, NotarizeMandateParams, NotarizeMandateResult, NotarizeCounterProposeParams, NotarizeReceiptParams, NotarizeReceiptResult, NotarizeVerdictParams, NotarizeVerifyParams, NotarizeVerifyResult, NotarizeHistory, ApiErrorResponse, ValidationErrorDetail, 
+/** @deprecated Use `ListParams` */
+PaginationParams, 
+/** @deprecated Use `Page<T>` */
+PaginatedResponse, 
+/** @deprecated Use `Page<T>` */
+CursorPaginatedResponse, 
+/** @deprecated Use `AgledgerEvent` */
+AuditEvent, } from './types.js';
+export { AgledgerError, AgledgerApiError, AuthenticationError, PermissionError, NotFoundError, ValidationError, UnprocessableError, RateLimitError, ConnectionError, TimeoutError, } from './errors.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,12 @@
+/**
+ * AGLedger™ SDK v1.0.0
+ * Accountability and audit infrastructure for agentic systems.
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ *
+ * @packageDocumentation
+ */
+// Client
+export { AgledgerClient } from './client.js';
+// Error classes
+export { AgledgerError, AgledgerApiError, AuthenticationError, PermissionError, NotFoundError, ValidationError, UnprocessableError, RateLimitError, ConnectionError, TimeoutError, } from './errors.js';
+//# sourceMappingURL=index.js.map

package/dist/resources/a2a.d.ts

@@ -0,0 +1,22 @@
+/**
+ * AGLedger™ SDK — A2A Protocol Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ *
+ * Agent-to-Agent protocol support (agent discovery + JSON-RPC 2.0).
+ */
+import type { HttpClient } from '../http.js';
+import type { AgentCard, JsonRpcRequest, JsonRpcResponse, RequestOptions } from '../types.js';
+export declare class A2aResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** Fetch the platform's AgentCard for A2A discovery. */
+    getAgentCard(options?: RequestOptions): Promise<AgentCard>;
+    /** Dispatch a JSON-RPC 2.0 request to the A2A endpoint. */
+    dispatch(request: JsonRpcRequest, options?: RequestOptions): Promise<JsonRpcResponse>;
+    /**
+     * Convenience: call a named A2A method with params.
+     * Auto-generates JSON-RPC envelope with id.
+     */
+    call(method: string, params?: Record<string, unknown>, options?: RequestOptions): Promise<JsonRpcResponse>;
+}
+//# sourceMappingURL=a2a.d.ts.map

package/dist/resources/a2a.js

@@ -0,0 +1,33 @@
+/**
+ * AGLedger™ SDK — A2A Protocol Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ *
+ * Agent-to-Agent protocol support (agent discovery + JSON-RPC 2.0).
+ */
+export class A2aResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /** Fetch the platform's AgentCard for A2A discovery. */
+    async getAgentCard(options) {
+        return this.http.get('/.well-known/agent-card.json', undefined, options);
+    }
+    /** Dispatch a JSON-RPC 2.0 request to the A2A endpoint. */
+    async dispatch(request, options) {
+        return this.http.post('/a2a', request, options);
+    }
+    /**
+     * Convenience: call a named A2A method with params.
+     * Auto-generates JSON-RPC envelope with id.
+     */
+    async call(method, params, options) {
+        return this.dispatch({
+            jsonrpc: '2.0',
+            method,
+            params,
+            id: crypto.randomUUID(),
+        }, options);
+    }
+}
+//# sourceMappingURL=a2a.js.map

package/dist/resources/admin.d.ts

@@ -0,0 +1,39 @@
+/**
+ * AGLedger™ SDK — Admin Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ *
+ * Platform-only operations. Requires platform-level API key.
+ */
+import type { HttpClient } from '../http.js';
+import type { AdminEnterprise, AdminAgent, AdminApiKey, WebhookDlqEntry, SystemHealth, UpdateTrustLevelParams, SetCapabilitiesParams, Page, ListParams, RequestOptions, ContractType } from '../types.js';
+export declare class AdminResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    listEnterprises(params?: ListParams, options?: RequestOptions): Promise<Page<AdminEnterprise>>;
+    listAgents(params?: ListParams, options?: RequestOptions): Promise<Page<AdminAgent>>;
+    updateTrustLevel(accountId: string, params: UpdateTrustLevelParams, options?: RequestOptions): Promise<Record<string, unknown>>;
+    setCapabilities(agentId: string, params: SetCapabilitiesParams, options?: RequestOptions): Promise<Record<string, unknown>>;
+    getFleetCapabilities(options?: RequestOptions): Promise<Page<{
+        agentId: string;
+        capabilities: ContractType[];
+    }>>;
+    listApiKeys(params?: ListParams, options?: RequestOptions): Promise<Page<AdminApiKey>>;
+    createApiKey(params: {
+        ownerId: string;
+        ownerType: string;
+    }, options?: RequestOptions): Promise<{
+        apiKey: string;
+        keyId: string;
+    }>;
+    toggleApiKey(keyId: string, active: boolean, options?: RequestOptions): Promise<AdminApiKey>;
+    bulkRevokeApiKeys(keyIds: string[], options?: RequestOptions): Promise<{
+        revoked: number;
+    }>;
+    listDlq(params?: ListParams, options?: RequestOptions): Promise<Page<WebhookDlqEntry>>;
+    retryDlq(dlqId: string, options?: RequestOptions): Promise<Record<string, unknown>>;
+    retryAllDlq(options?: RequestOptions): Promise<{
+        retried: number;
+    }>;
+    getSystemHealth(options?: RequestOptions): Promise<SystemHealth>;
+}
+//# sourceMappingURL=admin.d.ts.map

package/dist/resources/admin.js

@@ -0,0 +1,57 @@
+/**
+ * AGLedger™ SDK — Admin Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ *
+ * Platform-only operations. Requires platform-level API key.
+ */
+export class AdminResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    // --- Enterprises ---
+    async listEnterprises(params, options) {
+        return this.http.getPage('/v1/admin/enterprises', params, options);
+    }
+    // --- Agents ---
+    async listAgents(params, options) {
+        return this.http.getPage('/v1/admin/agents', params, options);
+    }
+    async updateTrustLevel(accountId, params, options) {
+        return this.http.patch(`/v1/admin/accounts/${accountId}/trust-level`, params, options);
+    }
+    async setCapabilities(agentId, params, options) {
+        return this.http.patch(`/v1/admin/agents/${agentId}/capabilities`, params, options);
+    }
+    async getFleetCapabilities(options) {
+        return this.http.getPage('/v1/admin/agents/capabilities', undefined, options);
+    }
+    // --- API Keys ---
+    async listApiKeys(params, options) {
+        return this.http.getPage('/v1/admin/api-keys', params, options);
+    }
+    async createApiKey(params, options) {
+        return this.http.post('/v1/admin/api-keys', params, options);
+    }
+    async toggleApiKey(keyId, active, options) {
+        return this.http.patch(`/v1/admin/api-keys/${keyId}`, { active }, options);
+    }
+    async bulkRevokeApiKeys(keyIds, options) {
+        return this.http.post('/v1/admin/api-keys/bulk-revoke', { keyIds }, options);
+    }
+    // --- Webhook DLQ ---
+    async listDlq(params, options) {
+        return this.http.getPage('/v1/admin/webhook-dlq', params, options);
+    }
+    async retryDlq(dlqId, options) {
+        return this.http.post(`/v1/admin/webhook-dlq/${dlqId}/retry`, undefined, options);
+    }
+    async retryAllDlq(options) {
+        return this.http.post('/v1/admin/webhook-dlq/retry-all', undefined, options);
+    }
+    // --- System Health ---
+    async getSystemHealth(options) {
+        return this.http.get('/v1/admin/system-health', undefined, options);
+    }
+}
+//# sourceMappingURL=admin.js.map

package/dist/resources/capabilities.d.ts

@@ -0,0 +1,23 @@
+/**
+ * AGLedger™ SDK — Capabilities Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ *
+ * Manage agent contract type capabilities.
+ */
+import type { HttpClient } from '../http.js';
+import type { ContractType, SetCapabilitiesParams, RequestOptions } from '../types.js';
+export declare class CapabilitiesResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** Get an agent's registered contract type capabilities. */
+    get(agentId: string, options?: RequestOptions): Promise<{
+        agentId: string;
+        capabilities: ContractType[];
+    }>;
+    /** Set the authenticated agent's own capabilities. */
+    set(agentId: string, params: SetCapabilitiesParams, options?: RequestOptions): Promise<{
+        agentId: string;
+        capabilities: ContractType[];
+    }>;
+}
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/resources/capabilities.js

@@ -0,0 +1,21 @@
+/**
+ * AGLedger™ SDK — Capabilities Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ *
+ * Manage agent contract type capabilities.
+ */
+export class CapabilitiesResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /** Get an agent's registered contract type capabilities. */
+    async get(agentId, options) {
+        return this.http.get(`/v1/agents/${agentId}/capabilities`, undefined, options);
+    }
+    /** Set the authenticated agent's own capabilities. */
+    async set(agentId, params, options) {
+        return this.http.patch(`/v1/agents/${agentId}/capabilities`, params, options);
+    }
+}
+//# sourceMappingURL=capabilities.js.map

package/dist/resources/compliance.d.ts

@@ -0,0 +1,34 @@
+/**
+ * AGLedger™ SDK — Compliance & EU AI Act Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ */
+import type { HttpClient } from '../http.js';
+import type { ComplianceExport, ExportComplianceParams, AiImpactAssessment, CreateAiImpactAssessmentParams, EuAiActReport, RequestOptions } from '../types.js';
+export declare class ComplianceResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    export(params: ExportComplianceParams, options?: RequestOptions): Promise<ComplianceExport>;
+    getExportStatus(exportId: string, options?: RequestOptions): Promise<ComplianceExport>;
+    /**
+     * Poll until a compliance export is ready or timeout.
+     * Returns the completed export, or throws if it times out.
+     */
+    waitForExport(exportId: string, opts?: {
+        pollIntervalMs?: number;
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<ComplianceExport>;
+    createAssessment(mandateId: string, params: CreateAiImpactAssessmentParams, options?: RequestOptions): Promise<AiImpactAssessment>;
+    getAssessment(mandateId: string, options?: RequestOptions): Promise<AiImpactAssessment>;
+    getEuAiActReport(params?: {
+        from?: string;
+        to?: string;
+    }, options?: RequestOptions): Promise<EuAiActReport>;
+    getEnterpriseReport(params?: {
+        from?: string;
+        to?: string;
+        format?: string;
+    }, options?: RequestOptions): Promise<Record<string, unknown>>;
+    analyzeAudit(mandateId: string, options?: RequestOptions): Promise<Record<string, unknown>>;
+}
+//# sourceMappingURL=compliance.d.ts.map

package/dist/resources/compliance.js

@@ -0,0 +1,54 @@
+/**
+ * AGLedger™ SDK — Compliance & EU AI Act Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ */
+export class ComplianceResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    // --- Compliance Export ---
+    async export(params, options) {
+        return this.http.post('/v1/compliance/export', params, options);
+    }
+    async getExportStatus(exportId, options) {
+        return this.http.get(`/v1/compliance/export/${exportId}`, undefined, options);
+    }
+    /**
+     * Poll until a compliance export is ready or timeout.
+     * Returns the completed export, or throws if it times out.
+     */
+    async waitForExport(exportId, opts) {
+        const interval = opts?.pollIntervalMs ?? 2_000;
+        const timeout = opts?.timeoutMs ?? 120_000;
+        const deadline = Date.now() + timeout;
+        while (Date.now() < deadline) {
+            if (opts?.signal?.aborted) {
+                throw new Error('Export wait cancelled');
+            }
+            const result = await this.getExportStatus(exportId);
+            if (result.status === 'ready')
+                return result;
+            await new Promise((r) => setTimeout(r, interval));
+        }
+        throw new Error(`Export ${exportId} did not complete within ${timeout}ms`);
+    }
+    // --- EU AI Act ---
+    async createAssessment(mandateId, params, options) {
+        return this.http.post(`/v1/mandates/${mandateId}/ai-impact-assessment`, params, options);
+    }
+    async getAssessment(mandateId, options) {
+        return this.http.get(`/v1/mandates/${mandateId}/ai-impact-assessment`, undefined, options);
+    }
+    async getEuAiActReport(params, options) {
+        return this.http.get('/v1/compliance/eu-ai-act/report', params, options);
+    }
+    // --- Audit Reports ---
+    async getEnterpriseReport(params, options) {
+        return this.http.get('/v1/audit/enterprise-report', params, options);
+    }
+    async analyzeAudit(mandateId, options) {
+        return this.http.post('/v1/audit/enterprise-report/analyze', { mandateId }, options);
+    }
+}
+//# sourceMappingURL=compliance.js.map

package/dist/resources/dashboard.d.ts

@@ -0,0 +1,14 @@
+/**
+ * AGLedger™ SDK — Dashboard Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ */
+import type { HttpClient } from '../http.js';
+import type { DashboardSummary, DashboardMetrics, DashboardMetricsParams, DashboardAgent, DashboardAgentParams, Page, RequestOptions } from '../types.js';
+export declare class DashboardResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    getSummary(options?: RequestOptions): Promise<DashboardSummary>;
+    getMetrics(params?: DashboardMetricsParams, options?: RequestOptions): Promise<DashboardMetrics>;
+    listAgents(params?: DashboardAgentParams, options?: RequestOptions): Promise<Page<DashboardAgent>>;
+}
+//# sourceMappingURL=dashboard.d.ts.map

package/dist/resources/dashboard.js

@@ -0,0 +1,20 @@
+/**
+ * AGLedger™ SDK — Dashboard Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ */
+export class DashboardResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async getSummary(options) {
+        return this.http.get('/v1/dashboard/summary', undefined, options);
+    }
+    async getMetrics(params, options) {
+        return this.http.get('/v1/dashboard/metrics', params, options);
+    }
+    async listAgents(params, options) {
+        return this.http.getPage('/v1/dashboard/agents', params, options);
+    }
+}
+//# sourceMappingURL=dashboard.js.map

package/dist/resources/disputes.d.ts

@@ -0,0 +1,16 @@
+/**
+ * AGLedger™ SDK — Disputes Resource
+ * Patent Pending. Copyright 2026 AGLedger LLC. All rights reserved.
+ */
+import type { HttpClient } from '../http.js';
+import type { Dispute, CreateDisputeParams, ResolveDisputeParams, RequestOptions } from '../types.js';
+export declare class DisputesResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    create(mandateId: string, params: CreateDisputeParams, options?: RequestOptions): Promise<Dispute>;
+    get(mandateId: string, options?: RequestOptions): Promise<Dispute>;
+    escalate(mandateId: string, reason: string, options?: RequestOptions): Promise<Dispute>;
+    submitEvidence(mandateId: string, evidence: Record<string, unknown>, options?: RequestOptions): Promise<Dispute>;
+    resolve(mandateId: string, params: ResolveDisputeParams, options?: RequestOptions): Promise<Dispute>;
+}
+//# sourceMappingURL=disputes.d.ts.map