@frihet/mcp-server 1.16.6 → 2.0.0

package/dist/demo-client.d.ts

@@ -18,7 +18,8 @@
  *     stamp; this is the one accepted, documented gap).
  */
 import type { IFrihetClient } from "./client-interface.js";
-import type { PaginatedResponse } from "./types.js";
+import type { CreateWebhookInput, CreateWebhookResult, PaginatedResponse, UpdateWebhookInput, Webhook } from "./types.js";
+import { type BinaryDocument, type EInvoiceDocument, type EInvoiceExportResult, type McpEInvoiceExportFormat } from "./client.js";
 type Rec = Record<string, unknown>;
 export declare class DemoFrihetClient implements IFrihetClient {
     listInvoices(params?: {
@@ -75,8 +76,8 @@ export declare class DemoFrihetClient implements IFrihetClient {
     deleteVendor(_id: string): Promise<void>;
     sendInvoice(id: string, to?: string): Promise<Rec>;
     markInvoicePaid(id: string, paidDate?: string): Promise<Rec>;
-    getInvoicePdf(id: string): Promise<Rec>;
-    getInvoiceEInvoice(invoiceId: string): Promise<Rec>;
+    getInvoicePdf(id: string): Promise<BinaryDocument>;
+    getInvoiceEInvoice(invoiceId: string): Promise<EInvoiceDocument>;
     createCreditNote(invoiceId: string, data: {
         reason: string;
         reasonDescription?: string;
@@ -88,14 +89,31 @@ export declare class DemoFrihetClient implements IFrihetClient {
         daysOverdue?: number;
     }): Promise<Rec>;
     sendQuote(id: string, to?: string): Promise<Rec>;
-    listWebhooks(params?: {
+    listWebhooks(): Promise<{
+        data: Webhook[];
+        total: number;
+        _demo?: true;
+        _demoNotice?: string;
+    }>;
+    getWebhook(id: string): Promise<Webhook>;
+    createWebhook(data: CreateWebhookInput): Promise<CreateWebhookResult>;
+    updateWebhook(id: string, data: UpdateWebhookInput): Promise<Webhook>;
+    deleteWebhook(_id: string): Promise<void>;
+    globalSearch(params: {
+        q: string;
+        types?: ReadonlyArray<"invoices" | "expenses" | "vendors" | "clients" | "products">;
         limit?: number;
         offset?: number;
-    }): Promise<PaginatedResponse<Rec>>;
-    getWebhook(id: string): Promise<Rec>;
-    createWebhook(data: Rec): Promise<Rec>;
-    updateWebhook(id: string, data: Rec): Promise<Rec>;
-    deleteWebhook(_id: string): Promise<void>;
+    }): Promise<{
+        data: Record<string, unknown>[];
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        query: string;
+        types: ReadonlyArray<"invoices" | "expenses" | "vendors" | "clients" | "products">;
+        truncated?: boolean;
+    }>;
     listClientContacts(_clientId: string, params?: {
         limit?: number;
         offset?: number;
@@ -106,7 +124,7 @@ export declare class DemoFrihetClient implements IFrihetClient {
         limit?: number;
         offset?: number;
     }): Promise<PaginatedResponse<Rec>>;
-    logClientActivity(clientId: string, data: Rec): Promise<Rec>;
+    logClientActivity(_clientId: string, data: Rec): Promise<Rec>;
     listClientNotes(_clientId: string, params?: {
         limit?: number;
         offset?: number;
@@ -170,14 +188,9 @@ export declare class DemoFrihetClient implements IFrihetClient {
     }>;
     exportEInvoice(params: {
         invoiceId: string;
-        format: string;
+        format: McpEInvoiceExportFormat;
         signed?: boolean;
-    }): Promise<{
-        xmlUrl: string;
-        filename: string;
-        format: string;
-        signed: boolean;
-    }>;
+    }): Promise<EInvoiceExportResult>;
     faceSubmit(params: {
         invoiceId: string;
         mode: "mock" | "sandbox" | "production";
@@ -311,7 +324,7 @@ export declare class DemoFrihetClient implements IFrihetClient {
     updateTeamMemberRole(memberId: string, role: string): Promise<Rec>;
     removeTeamMember(_memberId: string): Promise<void>;
     approveGLEntry(entryId: string, notes?: string): Promise<Rec>;
-    rejectGLEntry(entryId: string, reason: string): Promise<Rec>;
+    rejectGLEntry(entryId: string, note: string): Promise<Rec>;
     getGLEntryAuditLog(entryId: string): Promise<Rec>;
     addCustomPortalDomain(data: {
         domain: string;
@@ -352,15 +365,13 @@ export declare class DemoFrihetClient implements IFrihetClient {
     }): Promise<PaginatedResponse<Rec>>;
     createBankRule(data: {
         name: string;
-        conditions: Array<{
+        bankConditions: Array<{
             field: string;
             operator: string;
             value: string;
         }>;
-        actions: Array<{
-            type: string;
-            value: string;
-        }>;
+        action: string;
+        actionConfig: Record<string, unknown>;
         isActive?: boolean;
     }): Promise<Rec>;
     sendGestoriaMessage(data: {
@@ -403,7 +414,9 @@ export declare class DemoFrihetClient implements IFrihetClient {
         };
     }): Promise<Rec>;
     getGestoriaAgingConsolidated(_params?: {
-        ownerUid?: string;
+        workspaceIds?: string[];
+        asOf?: string;
+        bustCache?: boolean;
     }): Promise<Rec>;
     listLeaves(params?: {
         limit?: number;
@@ -427,8 +440,8 @@ export declare class DemoFrihetClient implements IFrihetClient {
         employeeId: string;
         mood?: string;
         location?: string;
-    }): Promise<Rec>;
-    attendanceClockOut(entryId: string): Promise<Rec>;
+    }, _idempotencyKey?: string): Promise<Rec>;
+    attendanceClockOut(entryId: string, _idempotencyKey?: string): Promise<Rec>;
     getOvertimeReport(params: {
         period: string;
         employeeId?: string;
@@ -441,20 +454,16 @@ export declare class DemoFrihetClient implements IFrihetClient {
         eventType?: string;
     }): Promise<Rec>;
     exportPayroll(params: {
-        format: "a3" | "contasol" | "sage" | "holded" | "siltra";
+        format: "a3" | "contasol" | "sage" | "siltra";
         month: string;
     }): Promise<Rec>;
     getPayrollChecklist(params: {
         month: string;
     }): Promise<Rec>;
-    getOnboardingStatus(): Promise<Rec>;
-    setOnboardingPersona(data: {
-        persona: "autonomo" | "empresa" | "agencia" | "gestoria";
-    }): Promise<Rec>;
     getPermissionsMatrix(): Promise<Rec>;
     getMyPermissions(): Promise<Rec>;
     getCurrentPeriod(params?: {
-        periodId?: string;
+        fiscalYear?: string;
     }): Promise<Rec>;
     closePeriod(data: {
         type: "monthly" | "quarterly";

package/dist/demo-client.js

@@ -17,7 +17,63 @@
  *   - delete / remove methods → resolve void (interface return type forbids a
  *     stamp; this is the one accepted, documented gap).
  */
+import { toApiEInvoiceExportFormat, } from "./client.js";
+import { Buffer } from "node:buffer";
 import { READ_STAMP, FISCAL_STAMP, DEMO_NOW, demoPage, demoEmptyPage, findOrStub, demoId, simulateWrite, simulateAction, demoClients, demoProducts, demoInvoices, demoExpenses, demoQuotes, demoVendors, demoBankAccounts, demoTransactions, } from "./demo-fixtures.js";
+const DEMO_RBAC_ROLES = ["owner", "admin", "manager", "sales", "accountant", "employee", "viewer"];
+const DEMO_RBAC_RESOURCES = [
+    "workspace", "invoices", "quotes", "expenses", "clients", "products", "accounting",
+    "people", "payroll", "integrations", "banking", "settings", "audit_log", "billing",
+];
+const DEMO_RBAC_ACTIONS = ["read", "create", "update", "delete", "bulk_delete", "export"];
+const DEMO_FULL_ACTIONS = [...DEMO_RBAC_ACTIONS];
+const DEMO_PERMISSION_MATRIX = {
+    owner: {
+        workspace: ["read", "update", "export"],
+        invoices: DEMO_FULL_ACTIONS, quotes: DEMO_FULL_ACTIONS, expenses: DEMO_FULL_ACTIONS,
+        clients: DEMO_FULL_ACTIONS, products: DEMO_FULL_ACTIONS, accounting: DEMO_FULL_ACTIONS,
+        people: DEMO_FULL_ACTIONS, payroll: DEMO_FULL_ACTIONS, integrations: DEMO_FULL_ACTIONS,
+        banking: ["read", "create", "update", "delete", "export"],
+        settings: ["read", "update"], audit_log: ["read", "export"],
+        billing: ["read", "create", "update", "delete", "export"],
+    },
+    admin: {
+        workspace: ["read", "update", "export"],
+        invoices: DEMO_FULL_ACTIONS, quotes: DEMO_FULL_ACTIONS, expenses: DEMO_FULL_ACTIONS,
+        clients: DEMO_FULL_ACTIONS, products: DEMO_FULL_ACTIONS, accounting: DEMO_FULL_ACTIONS,
+        people: DEMO_FULL_ACTIONS, payroll: DEMO_FULL_ACTIONS, integrations: DEMO_FULL_ACTIONS,
+        banking: ["read", "create", "update", "delete", "export"],
+        settings: ["read", "update"], audit_log: ["read", "export"],
+    },
+    manager: {
+        workspace: ["read"], invoices: ["read", "export"], quotes: ["read", "export"],
+        clients: ["read", "export"], products: ["read", "export"], expenses: ["read", "export"],
+        banking: ["read"], people: DEMO_FULL_ACTIONS, payroll: ["read", "export"],
+        settings: ["read"], integrations: ["read"], audit_log: ["read"],
+    },
+    sales: {
+        workspace: ["read"], invoices: ["read", "create", "update", "export"],
+        quotes: ["read", "create", "update", "export"], clients: ["read", "create", "update", "export"],
+        products: ["read", "export"], expenses: ["read", "export"],
+    },
+    accountant: {
+        workspace: ["read"], invoices: ["read", "create", "update", "export"],
+        quotes: ["read", "export"], expenses: ["read", "create", "update", "export"],
+        clients: ["read", "export"], products: ["read", "export"],
+        banking: ["read", "create", "update", "export"], accounting: ["read", "create", "update", "export"],
+        people: ["read"], audit_log: ["read", "export"],
+    },
+    employee: { workspace: ["read"] },
+    viewer: {
+        workspace: ["read", "export"], invoices: ["read", "export"], quotes: ["read", "export"],
+        expenses: ["read", "export"], clients: ["read", "export"], products: ["read", "export"],
+        banking: ["read"], accounting: ["read", "export"], people: ["read"], payroll: ["read"],
+        settings: ["read"], integrations: ["read"], audit_log: ["read"],
+    },
+};
+const DEMO_OWNER_CAPABILITIES = Object.entries(DEMO_PERMISSION_MATRIX.owner)
+    .flatMap(([resource, actions]) => actions.map((action) => `${resource}:${action}`))
+    .sort();
 export class DemoFrihetClient {
     // ---------------------------------------------------------------- Invoices
     async listInvoices(params) {
@@ -139,13 +195,27 @@ export class DemoFrihetClient {
         return simulateAction(id, { status: "paid", paidAt: paidDate ?? DEMO_NOW });
     }
     async getInvoicePdf(id) {
-        return { id, url: "https://app.frihet.io/demo/invoice.pdf", contentType: "application/pdf", ...READ_STAMP };
+        // #1393: shape mirrors the live BinaryDocument contract (id,
+        // contentType, sizeBytes, base64) so demo-mode outputSchema validation
+        // runs against the same fields as the live path.
+        const demoPdfBytes = Buffer.from("%PDF-1.4\n%%DEMO e-invoice for " + id + "\n%%EOF\n", "utf8");
+        return {
+            id,
+            contentType: "application/pdf",
+            sizeBytes: demoPdfBytes.byteLength,
+            base64: demoPdfBytes.toString("base64"),
+            ...READ_STAMP,
+        };
     }
     async getInvoiceEInvoice(invoiceId) {
+        // #1393: mirrors the live XML arm of the MIME-discriminated contract.
+        const xml = `<?xml version="1.0" encoding="UTF-8"?>\n<Invoice><!-- DEMO example e-invoice for ${invoiceId} --></Invoice>`;
         return {
-            xml: `<?xml version="1.0" encoding="UTF-8"?>\n<Invoice><!-- DEMO example e-invoice for ${invoiceId} --></Invoice>`,
+            id: invoiceId,
+            xml,
+            contentType: "application/xml; charset=utf-8",
+            sizeBytes: Buffer.byteLength(xml, "utf8"),
             filename: `${invoiceId}.xml`,
-            format: "facturae",
             ...FISCAL_STAMP,
         };
     }
@@ -190,21 +260,60 @@ export class DemoFrihetClient {
         return { id, status: "sent", sentAt: DEMO_NOW, ...(to ? { to } : {}), ...FISCAL_STAMP };
     }
     // ---------------------------------------------------------------- Webhooks
-    async listWebhooks(params) {
-        return demoEmptyPage(params);
+    async listWebhooks() {
+        const { data, total } = demoEmptyPage();
+        return { data: data, total };
     }
     async getWebhook(id) {
-        return { id, ...READ_STAMP };
+        return {
+            id,
+            name: "Demo webhook",
+            url: "https://example.com/webhooks/frihet",
+            events: ["invoice.paid"],
+            status: "active",
+            metadata: { demo: true },
+            hasSecret: false,
+            createdAt: DEMO_NOW,
+            updatedAt: DEMO_NOW,
+            ...READ_STAMP,
+        };
     }
     async createWebhook(data) {
-        return simulateWrite("demo_wh", data, { active: data.active ?? true });
+        return simulateWrite("demo_wh", { ...data }, {
+            status: data.status ?? "active",
+            hasSecret: typeof data.secret === "string" && data.secret.length > 0,
+        });
     }
     async updateWebhook(id, data) {
-        return simulateAction(id, { ...data });
+        const { secret, ...fields } = data;
+        const { success: _success, ...result } = simulateAction(id, {
+            name: "Demo webhook",
+            url: "https://example.com/webhooks/frihet",
+            events: ["invoice.paid"],
+            status: "active",
+            metadata: { demo: true },
+            hasSecret: typeof secret === "string" && secret.length > 0,
+            ...fields,
+        });
+        return result;
     }
     async deleteWebhook(_id) {
         return;
     }
+    // ---------------------------------------------------------------- Cross-resource search
+    // ----------------------------------------------------------------
+    async globalSearch(params) {
+        return {
+            data: [],
+            total: 0,
+            limit: params.limit ?? 25,
+            offset: params.offset ?? 0,
+            hasMore: false,
+            query: params.q,
+            types: params.types ?? ["invoices", "expenses", "vendors", "clients", "products"],
+            truncated: false,
+        };
+    }
     // ---------------------------------------------------------------- CRM: Contacts
     async listClientContacts(_clientId, params) {
         return demoEmptyPage(params);
@@ -219,8 +328,13 @@ export class DemoFrihetClient {
     async listClientActivities(_clientId, params) {
         return demoEmptyPage(params);
     }
-    async logClientActivity(clientId, data) {
-        return simulateWrite("demo_act", data, { clientId });
+    async logClientActivity(_clientId, data) {
+        return simulateWrite("demo_act", data, {
+            type: data.type === "email" ? "email_sent" : data.type,
+            timestamp: DEMO_NOW,
+            createdBy: "user",
+            metadata: {},
+        });
     }
     // ---------------------------------------------------------------- CRM: Notes
     async listClientNotes(_clientId, params) {
@@ -327,7 +441,15 @@ export class DemoFrihetClient {
         return { fileUrl: "https://app.frihet.io/demo/datev.csv", filename: "demo-datev.csv", rowCount: 24, fiscalPeriod: `${params.periodStart}..${params.periodEnd}`, encoding: "cp1252", ...FISCAL_STAMP };
     }
     async exportEInvoice(params) {
-        return { xmlUrl: "https://app.frihet.io/demo/einvoice.xml", filename: `${params.invoiceId}.xml`, format: params.format, signed: params.signed ?? false, ...FISCAL_STAMP };
+        const format = toApiEInvoiceExportFormat(params.format);
+        return {
+            xml: `<?xml version="1.0" encoding="UTF-8"?><DemoEInvoice format="${format}"/>`,
+            contentType: "application/xml",
+            filename: `${params.invoiceId}.xml`,
+            format,
+            signed: params.signed ?? false,
+            ...FISCAL_STAMP,
+        };
     }
     async faceSubmit(params) {
         return { registroFACe: "DEMO-FACE-0001", status: "submitted", submittedAt: DEMO_NOW, mode: params.mode, ...FISCAL_STAMP };
@@ -404,7 +526,8 @@ export class DemoFrihetClient {
     }
     // ---------------------------------------------------------------- Fiscal (simulated / read summaries)
     async getFiscalModeloSummary(modeloCode, period) {
-        return { model: modeloCode, period: period ?? "2026-Q2", readonly: true, summary: { totalRevenue: 3960.4, totalExpenses: 405.6 }, ...FISCAL_STAMP };
+        const defaultPeriod = modeloCode === "390" || modeloCode === "347" ? "2026" : "2026-Q2";
+        return { model: modeloCode, period: period ?? defaultPeriod, readonly: true, summary: { totalRevenue: 3960.4, totalExpenses: 405.6 }, ...FISCAL_STAMP };
     }
     async getVerifactuStatus(invoiceId) {
         return { invoiceId, status: "accepted", accepted: true, submittedAt: DEMO_NOW, ...FISCAL_STAMP };
@@ -476,8 +599,8 @@ export class DemoFrihetClient {
     async approveGLEntry(entryId, notes) {
         return simulateAction(entryId, { status: "approved", ...(notes ? { notes } : {}) });
     }
-    async rejectGLEntry(entryId, reason) {
-        return simulateAction(entryId, { status: "rejected", reason });
+    async rejectGLEntry(entryId, note) {
+        return simulateAction(entryId, { status: "rejected", note });
     }
     async getGLEntryAuditLog(entryId) {
         return { entryId, log: [], ...READ_STAMP };
@@ -515,7 +638,7 @@ export class DemoFrihetClient {
         return demoEmptyPage(params);
     }
     async createBankRule(data) {
-        return simulateWrite("demo_rule", { name: data.name, conditions: data.conditions, actions: data.actions }, { isActive: data.isActive ?? true });
+        return simulateWrite("demo_rule", { name: data.name, bankConditions: data.bankConditions, action: data.action, actionConfig: data.actionConfig }, { isActive: data.isActive ?? true });
     }
     // ---------------------------------------------------------------- Gestoria
     async sendGestoriaMessage(data) {
@@ -549,14 +672,24 @@ export class DemoFrihetClient {
     async cancelLeave(leaveId) {
         return simulateAction(leaveId, { status: "cancelled" });
     }
-    async attendanceClockIn(data) {
+    async attendanceClockIn(data, _idempotencyKey) {
         return simulateWrite("demo_att", { employeeId: data.employeeId, ...(data.mood ? { mood: data.mood } : {}), ...(data.location ? { location: data.location } : {}) }, { status: "open", clockInAt: DEMO_NOW });
     }
-    async attendanceClockOut(entryId) {
+    async attendanceClockOut(entryId, _idempotencyKey) {
         return simulateAction(entryId, { status: "closed", clockOutAt: DEMO_NOW });
     }
     async getOvertimeReport(params) {
-        return { period: params.period, totalRegularHours: 0, totalOvertimeHours: 0, byEmployee: [], generatedAt: DEMO_NOW, ...READ_STAMP };
+        return {
+            period: params.period,
+            employeeId: params.employeeId ?? null,
+            recordCount: 0,
+            dailyOvertime: [],
+            weeklyOvertime: [],
+            monthlyTotal: { workedMinutes: 0, overtimeMinutes: 0, regularMinutes: 0 },
+            annualOvertimeHours: 0,
+            alerts: [],
+            ...READ_STAMP,
+        };
     }
     async listAnomalies(params) {
         return demoEmptyPage(params);
@@ -565,30 +698,68 @@ export class DemoFrihetClient {
     async testWebhook(id, data) {
         return { webhookId: id, delivered: true, statusCode: 200, responseTimeMs: 42, eventType: data?.eventType ?? "ping", attemptedAt: DEMO_NOW, ...FISCAL_STAMP };
     }
-    // ---------------------------------------------------------------- Payroll (simulated fiscal)
+    // ---------------------------------------------------------------- Payroll (read-only demo)
     async exportPayroll(params) {
-        return { format: params.format, month: params.month, fileUrl: "https://app.frihet.io/demo/payroll.txt", filename: "demo-payroll.txt", rowCount: 0, generatedAt: DEMO_NOW, ...FISCAL_STAMP };
+        return {
+            month: params.month,
+            format: params.format,
+            employees: [],
+            summary: { exportedCount: 0, skippedNotReady: 0, totalGrossAnnual: 0 },
+            ...READ_STAMP,
+        };
     }
     async getPayrollChecklist(params) {
-        return { month: params.month, totalEmployees: 0, readyEmployees: 0, missingEmployees: 0, employees: [], generatedAt: DEMO_NOW, ...FISCAL_STAMP };
-    }
-    // ---------------------------------------------------------------- Onboarding
-    async getOnboardingStatus() {
-        return { workspaceId: "demo_ws_001", persona: "autonomo", completedSteps: ["profile"], pendingSteps: ["bank", "invoice"], percentComplete: 33, startedAt: DEMO_NOW, ...READ_STAMP };
-    }
-    async setOnboardingPersona(data) {
-        return { workspaceId: "demo_ws_001", persona: data.persona, updatedAt: DEMO_NOW, ...READ_STAMP };
+        return {
+            month: params.month,
+            employees: [],
+            summary: { total: 0, ready: 0, notReady: 0, reviewedThisMonth: 0 },
+            ...READ_STAMP,
+        };
     }
     // ---------------------------------------------------------------- Permissions
     async getPermissionsMatrix() {
-        return { roles: [{ role: "owner", permissions: ["*"] }], resources: ["invoices", "expenses", "clients"], generatedAt: DEMO_NOW, ...READ_STAMP };
+        return {
+            roles: DEMO_RBAC_ROLES,
+            resources: DEMO_RBAC_RESOURCES,
+            actions: DEMO_RBAC_ACTIONS,
+            legacyAliases: { editor: "sales" },
+            matrix: DEMO_PERMISSION_MATRIX,
+            source: "hand-maintained demo snapshot of the Frihet RBAC model; not derived from firestore.rules and not verified against it",
+            ...READ_STAMP,
+        };
     }
     async getMyPermissions() {
-        return { userId: "demo_user_001", role: "owner", permissions: ["*"], workspaceId: "demo_ws_001", ...READ_STAMP };
+        return {
+            role: "owner",
+            isOwner: true,
+            resources: DEMO_PERMISSION_MATRIX.owner,
+            scopes: DEMO_OWNER_CAPABILITIES,
+            legacyFieldSemantics: { resources: "rbacResources", scopes: "rbacCapabilities" },
+            rbac: {
+                role: "owner",
+                isOwner: true,
+                resources: DEMO_PERMISSION_MATRIX.owner,
+                capabilities: DEMO_OWNER_CAPABILITIES,
+            },
+            apiKeyScopes: [],
+            apiKeyUnrestricted: true,
+            denied: { einvoice: false },
+            deniedSemantics: "Known API-key scope denials only; not an exhaustive effective-authorization report.",
+            notIncluded: ["featureFlags", "deployedEndpoints"],
+            ...READ_STAMP,
+        };
     }
     // ---------------------------------------------------------------- Period close
     async getCurrentPeriod(params) {
-        return { id: params?.periodId ?? "demo_period_2026_07", type: "monthly", status: "open", startDate: "2026-07-01", endDate: "2026-07-31", ...READ_STAMP };
+        const fiscalYear = params?.fiscalYear ?? "2026";
+        return {
+            fiscalYear,
+            fiscalYearStart: "01-01",
+            status: "open",
+            dateRange: { from: `${fiscalYear}-01-01`, to: `${fiscalYear}-12-31` },
+            closing: null,
+            ...READ_STAMP,
+        };
     }
     async closePeriod(data) {
         return simulateWrite("demo_period", { type: data.type }, { status: "closed", closedAt: DEMO_NOW });

package/dist/demo-fixtures.d.ts

@@ -30,13 +30,13 @@ export declare const EMPTY_STAMP: DemoStamp;
 export declare const DEMO_NOW = "2026-07-15T10:00:00.000Z";
 /** Test IBAN (ECBS/AEAT example — never a real account). */
 export declare const DEMO_TEST_IBAN = "ES9121000418450200051332";
-export type DemoPaginated = PaginatedResponse<Record<string, unknown>> & DemoStamp;
-/** Wrap a fixture array in a stamped PaginatedResponse. */
+export type DemoPaginated = PaginatedResponse<Record<string, unknown>>;
+/** Wrap a fixture array in a PaginatedResponse. */
 export declare function demoPage(data: Record<string, unknown>[], params?: {
     limit?: number;
     offset?: number;
 }): DemoPaginated;
-/** Empty stamped PaginatedResponse for surfaces without dedicated fixtures. */
+/** Empty PaginatedResponse for surfaces without dedicated fixtures. */
 export declare function demoEmptyPage(params?: {
     limit?: number;
     offset?: number;

package/dist/demo-fixtures.js

@@ -36,24 +36,24 @@ export const EMPTY_STAMP = {
 export const DEMO_NOW = "2026-07-15T10:00:00.000Z";
 /** Test IBAN (ECBS/AEAT example — never a real account). */
 export const DEMO_TEST_IBAN = "ES9121000418450200051332";
-/** Wrap a fixture array in a stamped PaginatedResponse. */
+/** Wrap a fixture array in a PaginatedResponse. */
 export function demoPage(data, params) {
+    const limit = params?.limit ?? 50;
+    const offset = params?.offset ?? 0;
     return {
-        data,
+        data: data.slice(offset, offset + limit),
         total: data.length,
-        limit: params?.limit ?? 50,
-        offset: params?.offset ?? 0,
-        ...READ_STAMP,
+        limit,
+        offset,
     };
 }
-/** Empty stamped PaginatedResponse for surfaces without dedicated fixtures. */
+/** Empty PaginatedResponse for surfaces without dedicated fixtures. */
 export function demoEmptyPage(params) {
     return {
         data: [],
         total: 0,
         limit: params?.limit ?? 50,
         offset: params?.offset ?? 0,
-        ...EMPTY_STAMP,
     };
 }
 /* ------------------------------------------------------------------ */

package/dist/deposit-contract.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod/v4";
+/** Locally generated guidance only: never includes input values or provider text. */
+export declare class DepositInputError extends Error {
+    readonly statusCode = 400;
+    readonly errorCode = "invalid_deposit_input";
+    constructor(message: string);
+}
+/** Writable fields accepted by publicApi v132's strict deposits schema. */
+export declare const depositFields: {
+    clientId: z.ZodString;
+    clientName: z.ZodString;
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+    description: z.ZodString;
+    receivedDate: z.ZodString;
+    paymentMethod: z.ZodOptional<z.ZodString>;
+    paymentReference: z.ZodOptional<z.ZodString>;
+};
+/** Writable fields accepted by publicApi v132's strict /deposits/:id/apply schema. */
+export declare const applyDepositFields: {
+    invoiceId: z.ZodString;
+    invoiceNumber: z.ZodString;
+    amount: z.ZodNumber;
+};
+/** Validate deposit application payload against the strict backend contract before request I/O. */
+export declare function normalizeApplyDepositBody(input?: Record<string, unknown>): Record<string, unknown>;
+/** Preserve the established MCP date/reference names on the canonical API wire. */
+export declare function normalizeDepositBody(input: Record<string, unknown>, partial: boolean): Record<string, unknown>;
+//# sourceMappingURL=deposit-contract.d.ts.map

package/dist/deposit-contract.js

@@ -0,0 +1,76 @@
+import { z } from "zod/v4";
+/** Locally generated guidance only: never includes input values or provider text. */
+export class DepositInputError extends Error {
+    statusCode = 400;
+    errorCode = "invalid_deposit_input";
+    constructor(message) {
+        super(message);
+        this.name = "DepositInputError";
+    }
+}
+/** Writable fields accepted by publicApi v132's strict deposits schema. */
+export const depositFields = {
+    clientId: z.string().min(1).max(128),
+    clientName: z.string().min(1).max(500),
+    amount: z.number().positive(),
+    currency: z.string().length(3),
+    description: z.string().min(1).max(2000),
+    receivedDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+    paymentMethod: z.string().max(200).optional(),
+    paymentReference: z.string().max(200).optional(),
+};
+/** Writable fields accepted by publicApi v132's strict /deposits/:id/apply schema. */
+export const applyDepositFields = {
+    invoiceId: z.string().min(1).max(128),
+    invoiceNumber: z.string().min(1).max(200),
+    amount: z.number().positive(),
+};
+const applyDepositBody = z.object(applyDepositFields).strict();
+/** Validate deposit application payload against the strict backend contract before request I/O. */
+export function normalizeApplyDepositBody(input = {}) {
+    if (Object.prototype.hasOwnProperty.call(input, "notes")) {
+        throw new DepositInputError("Deposit application field 'notes' is not writable; the API does not accept it. / El campo 'notes' no se puede guardar al aplicar el depósito.");
+    }
+    const parsed = applyDepositBody.safeParse(input);
+    if (!parsed.success) {
+        const known = new Set(Object.keys(applyDepositFields));
+        const fields = [...new Set(parsed.error.issues.map((issue) => issue.path[0]).filter((field) => typeof field === "string" && known.has(field)))];
+        throw new DepositInputError(`Invalid deposit application input${fields.length ? ` (${fields.join(", ")})` : ""}. Provide invoiceId, invoiceNumber and a positive amount. / Indica invoiceId, invoiceNumber y un importe positivo.`);
+    }
+    return parsed.data;
+}
+const createDepositBody = z.object({
+    ...depositFields,
+    currency: depositFields.currency.default("EUR"),
+}).strict();
+// PATCH must not inject the create default or turn an empty update into a write.
+const updateDepositBody = z.object(depositFields).partial().strict().refine((fields) => Object.values(fields).some((value) => value !== undefined), { message: "Provide at least one writable deposit field / Indica al menos un campo del depósito" });
+/** Preserve the established MCP date/reference names on the canonical API wire. */
+export function normalizeDepositBody(input, partial) {
+    const body = { ...input };
+    for (const unsupported of ["status", "notes"]) {
+        if (Object.prototype.hasOwnProperty.call(body, unsupported)) {
+            throw new DepositInputError(`Deposit field '${unsupported}' is not writable; the API does not accept it. / El campo '${unsupported}' no se puede guardar en el depósito.`);
+        }
+    }
+    for (const [alias, canonical] of [["date", "receivedDate"], ["reference", "paymentReference"]]) {
+        if (body[alias] !== undefined) {
+            if (body[canonical] !== undefined && body[canonical] !== body[alias]) {
+                throw new DepositInputError(`Conflicting deposit fields '${alias}' and '${canonical}'. / Los campos '${alias}' y '${canonical}' no coinciden.`);
+            }
+            body[canonical] = body[alias];
+        }
+        delete body[alias];
+    }
+    const parsed = (partial ? updateDepositBody : createDepositBody).safeParse(body);
+    if (!parsed.success) {
+        const known = new Set(Object.keys(depositFields));
+        const fields = [...new Set(parsed.error.issues.map((issue) => issue.path[0]).filter((field) => typeof field === "string" && known.has(field)))];
+        const guidance = partial
+            ? "Provide at least one valid writable deposit field; date uses YYYY-MM-DD. / Indica al menos un campo editable válido; date usa YYYY-MM-DD."
+            : "Provide clientId, clientName, a positive amount, description and receivedDate (date) in YYYY-MM-DD format. / Indica clientId, clientName, un importe positivo, description y receivedDate (date) con formato YYYY-MM-DD.";
+        throw new DepositInputError(`Invalid deposit input${fields.length ? ` (${fields.join(", ")})` : ""}. ${guidance}`);
+    }
+    return parsed.data;
+}
+//# sourceMappingURL=deposit-contract.js.map

package/dist/fetch-no-redirect.d.ts

@@ -0,0 +1,3 @@
+/** Validate a manual-mode fetch response without owning any network authority. */
+export declare function rejectRedirectResponse(response: Response): Promise<Response>;
+//# sourceMappingURL=fetch-no-redirect.d.ts.map