@frihet/mcp-server 1.16.6 → 1.17.0

package/dist/capability-truth.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Public capability truth for the full Frihet MCP surfaces.
+ *
+ * Registration proves only that a tool name and handler exist. It does not
+ * prove that the backing API family is deployed, enabled for a workspace, or
+ * authorized for the caller. This profile adds a conservative, machine-readable
+ * fact to tools/list and corrects action annotations on the non-OpenAI surface.
+ *
+ * The OpenAI review profile reuses the same annotation corrections so every
+ * public surface reports side effects consistently.
+ */
+import type { ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
+export declare const CAPABILITY_META_KEY = "io.frihet/capability";
+export type CapabilityCallability = "api_dependent" | "runtime_checked" | "deferred" | "unavailable" | "local";
+export type ExternalSideEffect = "email_or_invitation" | "webhook_delivery_or_configuration" | "fiscal_or_einvoice_submission" | "external_provider_read" | "external_provider_configuration" | "money_movement" | "channel_sync";
+export interface PublicCapabilityTruth {
+    readonly registered: true;
+    readonly callability: CapabilityCallability;
+    readonly canonicalOperation: string;
+    readonly writesFrihet: boolean;
+    readonly externalInteraction: boolean;
+    readonly externalSideEffects: readonly ExternalSideEffect[];
+}
+export declare function correctToolAnnotations(name: string, annotations: ToolAnnotations | undefined): ToolAnnotations;
+export declare function buildPublicCapabilityTruth(name: string, annotations: ToolAnnotations | undefined): PublicCapabilityTruth;
+export declare function buildLocalDiscoveryCapability(name: string): PublicCapabilityTruth;
+/** Must run after grouped exposure (when grouped) and before registration. */
+export declare function applyPublicCapabilityTruth(server: any): void;
+//# sourceMappingURL=capability-truth.d.ts.map

package/dist/capability-truth.js

@@ -0,0 +1,254 @@
+/**
+ * Public capability truth for the full Frihet MCP surfaces.
+ *
+ * Registration proves only that a tool name and handler exist. It does not
+ * prove that the backing API family is deployed, enabled for a workspace, or
+ * authorized for the caller. This profile adds a conservative, machine-readable
+ * fact to tools/list and corrects action annotations on the non-OpenAI surface.
+ *
+ * The OpenAI review profile reuses the same annotation corrections so every
+ * public surface reports side effects consistently.
+ */
+export const CAPABILITY_META_KEY = "io.frihet/capability";
+const RUNTIME_CHECKED = new Set([
+    "anomaly_list",
+    "attendance_clock_in",
+    "attendance_clock_out",
+    "frihet_aiem_calculate",
+    "frihet_bank_rule_create",
+    "frihet_bank_rules_list",
+    "frihet_gl_entry_approve",
+    "frihet_gl_entry_audit_log",
+    "frihet_gl_entry_reject",
+    "frihet_modelo_200_summary",
+    "frihet_modelo_202_summary",
+    "frihet_modelo_415_summary",
+    "frihet_modelo_418_summary",
+    "frihet_modelo_425_summary",
+    "frihet_portal_domain_add",
+    "frihet_portal_domain_remove",
+    "frihet_portal_domain_verify",
+    "frihet_portal_onboard_link_generate",
+    "frihet_tax_id_vies_lookup",
+    "gestoria_template_create",
+    "get_modelo_130_summary",
+    "get_modelo_180_summary",
+    "get_modelo_303_summary",
+    "get_modelo_347_summary",
+    "get_modelo_390_summary",
+    "leave_approve",
+    "leave_cancel",
+    "leave_list",
+    "leave_reject",
+    "leave_request_create",
+    "onboarding_persona_set",
+    "onboarding_status",
+    "overtime_report",
+    "payroll_checklist",
+    "payroll_export",
+    "period_close_status",
+    "permissions_matrix",
+    "permissions_me",
+    "verifactu_resubmit",
+    "verifactu_status",
+    "send_einvoice",
+    "get_einvoice_status",
+    "validate_einvoice_xml",
+    "export_datev",
+    "einvoice_export",
+    "face_submit",
+    "face_status",
+    "ticketbai_submit",
+    "ticketbai_status",
+]);
+const DEFERRED = new Set([
+    "period_close",
+    "period_reopen",
+    "gestoria_message_send",
+    "gestoria_messages_list",
+    "gestoria_template_bulk_send",
+    "gestoria_aging_consolidated",
+    "create_reservation",
+    "sync_channel",
+]);
+const UNAVAILABLE = new Set(["ksef_submit"]);
+const DESTRUCTIVE_UPDATES = new Set([
+    // These writes can synchronously enqueue delivery to workspace webhooks.
+    // Once an external endpoint receives the event, that disclosure cannot be
+    // recalled even if the Frihet record itself remains editable.
+    "create_invoice",
+    "duplicate_invoice",
+    "create_credit_note",
+    "create_expense",
+    "create_quote",
+    "create_client",
+    "log_client_activity",
+    "create_product",
+    "frihet_gl_entry_approve",
+    "frihet_gl_entry_reject",
+    "send_einvoice",
+    "categorize_transaction",
+    "update_client",
+    "update_deposit",
+    "apply_deposit",
+    "refund_deposit",
+    "update_expense",
+    "leave_approve",
+    "leave_reject",
+    "leave_cancel",
+    "attendance_clock_out",
+    "update_invoice",
+    "send_invoice",
+    "mark_invoice_paid",
+    "update_kitchen_ticket",
+    "onboarding_persona_set",
+    "update_product",
+    "update_quote",
+    "send_quote",
+    "update_recurring_invoice",
+    "sync_channel",
+    "update_team_member_role",
+    "update_time_entry",
+    "update_vendor",
+    "update_webhook",
+    "match_transaction_to_invoice",
+    "verifactu_resubmit",
+    "pause_recurring_invoice",
+    "resume_recurring_invoice",
+    "run_recurring_now",
+    "frihet_portal_domain_verify",
+    "face_submit",
+    "ticketbai_submit",
+    "frihet_portal_domain_add",
+]);
+const NON_IDEMPOTENT = new Set([
+    "create_invoice",
+    "duplicate_invoice",
+    "create_credit_note",
+    "update_invoice",
+    "mark_invoice_paid",
+    "delete_invoice",
+    "create_expense",
+    "update_expense",
+    "create_quote",
+    "update_quote",
+    "delete_quote",
+    "create_client",
+    "log_client_activity",
+    "update_client",
+    "create_product",
+    "update_product",
+    "update_vendor",
+    "send_invoice",
+    "send_quote",
+    "sync_channel",
+    "verifactu_resubmit",
+    "frihet_portal_domain_verify",
+    "pause_recurring_invoice",
+    "resume_recurring_invoice",
+]);
+const WRITE_OVERRIDES = new Set(["frihet_portal_domain_verify"]);
+const EXTERNAL_SIDE_EFFECTS = {
+    create_invoice: ["webhook_delivery_or_configuration", "fiscal_or_einvoice_submission"],
+    duplicate_invoice: ["webhook_delivery_or_configuration"],
+    create_credit_note: ["webhook_delivery_or_configuration"],
+    update_invoice: ["webhook_delivery_or_configuration", "fiscal_or_einvoice_submission"],
+    mark_invoice_paid: ["webhook_delivery_or_configuration", "fiscal_or_einvoice_submission"],
+    delete_invoice: ["webhook_delivery_or_configuration", "fiscal_or_einvoice_submission"],
+    create_expense: ["webhook_delivery_or_configuration"],
+    update_expense: ["webhook_delivery_or_configuration"],
+    create_quote: ["webhook_delivery_or_configuration"],
+    update_quote: ["webhook_delivery_or_configuration"],
+    delete_quote: ["webhook_delivery_or_configuration"],
+    create_client: ["webhook_delivery_or_configuration"],
+    log_client_activity: ["webhook_delivery_or_configuration"],
+    update_client: ["webhook_delivery_or_configuration"],
+    create_product: ["webhook_delivery_or_configuration"],
+    update_product: ["webhook_delivery_or_configuration"],
+    send_invoice: [
+        "email_or_invitation",
+        "webhook_delivery_or_configuration",
+        "fiscal_or_einvoice_submission",
+    ],
+    send_quote: ["email_or_invitation", "webhook_delivery_or_configuration"],
+    invite_team_member: ["email_or_invitation"],
+    create_webhook: ["webhook_delivery_or_configuration"],
+    update_webhook: ["webhook_delivery_or_configuration"],
+    delete_webhook: ["webhook_delivery_or_configuration"],
+    test_webhook: ["webhook_delivery_or_configuration"],
+    send_einvoice: ["fiscal_or_einvoice_submission"],
+    face_submit: ["fiscal_or_einvoice_submission"],
+    face_status: ["external_provider_read"],
+    ticketbai_submit: ["fiscal_or_einvoice_submission"],
+    verifactu_resubmit: ["fiscal_or_einvoice_submission"],
+    gestoria_message_send: ["email_or_invitation"],
+    gestoria_template_bulk_send: ["email_or_invitation"],
+    frihet_tax_id_vies_lookup: ["external_provider_read"],
+    frihet_portal_domain_add: ["external_provider_configuration"],
+    frihet_portal_domain_verify: [
+        "external_provider_read",
+        "external_provider_configuration",
+    ],
+    frihet_portal_domain_remove: ["external_provider_configuration"],
+    refund_sale: ["money_movement"],
+    sync_channel: ["channel_sync"],
+};
+function callabilityFor(name) {
+    if (UNAVAILABLE.has(name))
+        return "unavailable";
+    if (DEFERRED.has(name))
+        return "deferred";
+    if (RUNTIME_CHECKED.has(name))
+        return "runtime_checked";
+    return "api_dependent";
+}
+export function correctToolAnnotations(name, annotations) {
+    const externalInteraction = Object.hasOwn(EXTERNAL_SIDE_EFFECTS, name);
+    return {
+        ...annotations,
+        ...(WRITE_OVERRIDES.has(name) ? { readOnlyHint: false } : {}),
+        ...(DESTRUCTIVE_UPDATES.has(name) ? { destructiveHint: true } : {}),
+        ...(NON_IDEMPOTENT.has(name) ? { idempotentHint: false } : {}),
+        ...(externalInteraction ? { openWorldHint: true } : {}),
+    };
+}
+export function buildPublicCapabilityTruth(name, annotations) {
+    const effects = Object.hasOwn(EXTERNAL_SIDE_EFFECTS, name)
+        ? EXTERNAL_SIDE_EFFECTS[name]
+        : [];
+    return {
+        registered: true,
+        callability: callabilityFor(name),
+        canonicalOperation: name,
+        writesFrihet: annotations?.readOnlyHint !== true,
+        externalInteraction: effects.length > 0,
+        externalSideEffects: effects,
+    };
+}
+export function buildLocalDiscoveryCapability(name) {
+    return {
+        registered: true,
+        callability: "local",
+        canonicalOperation: name,
+        writesFrihet: false,
+        externalInteraction: false,
+        externalSideEffects: [],
+    };
+}
+/** Must run after grouped exposure (when grouped) and before registration. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function applyPublicCapabilityTruth(server) {
+    const originalRegisterTool = server.registerTool.bind(server);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    server.registerTool = (name, config, handler) => {
+        const annotations = correctToolAnnotations(name, config?.annotations);
+        const capability = buildPublicCapabilityTruth(name, annotations);
+        config.annotations = annotations;
+        config._meta = {
+            ...(config?._meta ?? {}),
+            [CAPABILITY_META_KEY]: capability,
+        };
+        return originalRegisterTool(name, config, handler);
+    };
+}
+//# sourceMappingURL=capability-truth.js.map

package/dist/client-interface.d.ts

@@ -5,7 +5,7 @@
  * classes satisfy this interface via structural typing. Tool registration
  * functions depend on this interface so they can work with either client.
  */
-import type { PaginatedResponse } from "./types.js";
+import type { CreateWebhookInput, CreateWebhookResult, PaginatedResponse, UpdateWebhookInput, Webhook } from "./types.js";
 export interface IFrihetClient {
     listInvoices(params?: {
         limit?: number;
@@ -21,7 +21,12 @@ export interface IFrihetClient {
     getInvoice(id: string): Promise<Record<string, unknown>>;
     createInvoice(data: Record<string, unknown>): Promise<Record<string, unknown>>;
     updateInvoice(id: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
-    deleteInvoice(id: string): Promise<void>;
+    /**
+     * Resolves to the soft-cancel payload when the backend answered 200 (non-draft
+     * invoice CANCELLED, not destroyed — VeriFactu hash chain), or void/undefined
+     * when it answered 204 (draft really removed). See `FrihetClient.deleteInvoice`.
+     */
+    deleteInvoice(id: string): Promise<Record<string, unknown> | void>;
     searchInvoices(query: string, params?: {
         limit?: number;
         offset?: number;
@@ -83,7 +88,8 @@ export interface IFrihetClient {
     getQuote(id: string): Promise<Record<string, unknown>>;
     createQuote(data: Record<string, unknown>): Promise<Record<string, unknown>>;
     updateQuote(id: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
-    deleteQuote(id: string): Promise<void>;
+    /** Same 200-cancel / 204-destroy contract as {@link IFrihetClient.deleteInvoice}. */
+    deleteQuote(id: string): Promise<Record<string, unknown> | void>;
     listVendors(params?: {
         q?: string;
         limit?: number;
@@ -97,8 +103,8 @@ export interface IFrihetClient {
     deleteVendor(id: string): Promise<void>;
     sendInvoice(id: string, to?: string): Promise<Record<string, unknown>>;
     markInvoicePaid(id: string, paidDate?: string): Promise<Record<string, unknown>>;
-    getInvoicePdf(id: string): Promise<Record<string, unknown>>;
-    getInvoiceEInvoice(invoiceId: string): Promise<any>;
+    getInvoicePdf(id: string): Promise<import("./client.js").BinaryDocument>;
+    getInvoiceEInvoice(invoiceId: string): Promise<import("./client.js").EInvoiceDocument>;
     createCreditNote(invoiceId: string, data: {
         reason: string;
         reasonDescription?: string;
@@ -110,13 +116,15 @@ export interface IFrihetClient {
         daysOverdue?: number;
     }): Promise<any>;
     sendQuote(id: string, to?: string): Promise<Record<string, unknown>>;
-    listWebhooks(params?: {
-        limit?: number;
-        offset?: number;
-    }): Promise<PaginatedResponse<Record<string, unknown>>>;
-    getWebhook(id: string): Promise<Record<string, unknown>>;
-    createWebhook(data: Record<string, unknown>): Promise<Record<string, unknown>>;
-    updateWebhook(id: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
+    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>;
     listClientContacts(clientId: string, params?: {
         limit?: number;
@@ -519,7 +527,7 @@ export interface IFrihetClient {
         eventType?: string;
     }): Promise<Record<string, unknown>>;
     exportPayroll(params: {
-        format: "a3" | "contasol" | "sage" | "holded" | "siltra";
+        format: "a3" | "contasol" | "sage" | "siltra";
         month: string;
     }): Promise<Record<string, unknown>>;
     getPayrollChecklist(params: {
@@ -532,7 +540,7 @@ export interface IFrihetClient {
     getPermissionsMatrix(): Promise<Record<string, unknown>>;
     getMyPermissions(): Promise<Record<string, unknown>>;
     getCurrentPeriod(params?: {
-        periodId?: string;
+        fiscalYear?: string;
     }): Promise<Record<string, unknown>>;
     closePeriod(data: {
         type: "monthly" | "quarterly";

package/dist/client.d.ts

@@ -11,11 +11,63 @@
  * (`req.query.cursor`, functions/src/publicApi.ts in Frihet-ERP). `after`
  * is never sent on the wire. See src/__tests__/pagination-cursor-param.test.ts.
  */
-import type { PaginatedResponse } from "./types.js";
+import type { CreateWebhookInput, CreateWebhookResult, PaginatedResponse, UpdateWebhookInput, Webhook } from "./types.js";
+/**
+ * Hard size caps for document responses. Enforced TWICE: precheck on
+ * `Content-Length` (so an honest server doesn't waste bandwidth) and after
+ * streaming (so a missing/lying `Content-Length` still can't trigger an
+ * unbounded allocation).
+ *
+ *  - PDF: 25 MiB — generous for any ERP-issued invoice PDF, including
+ *    embedded logos, Facturae XML attachments, and stamp signatures.
+ *  - XML:  5 MiB — UBL / Facturae / PEPPOL documents stay well under 1 MiB
+ *    in practice; 5 MiB absorbs any historical / annex-laden outlier.
+ *
+ * Anything larger is rejected with `413 payload_too_large` BEFORE we allocate
+ * — the user sees a clean error, the worker doesn't OOM.
+ */
+export declare const MAX_PDF_BYTES: number;
+export declare const MAX_XML_BYTES: number;
+/**
+ * Bounded binary document response. Always base64-encoded because MCP
+ * `structuredContent` is JSON-only — raw `Uint8Array` would coerce to a
+ * sparse object on the wire.
+ */
+export interface BinaryDocument {
+    /** Echoed id from the request (invoice id), so callers can correlate. */
+    id: string;
+    /** Verbatim `Content-Type` from the response (e.g. `application/pdf`). */
+    contentType: string;
+    /** Byte length of the decoded body. Equal to the decoded base64 byte length. */
+    sizeBytes: number;
+    /** Base64-encoded bytes. */
+    base64: string;
+    /** Filename hint parsed from `Content-Disposition`, when present. */
+    filename?: string;
+}
+/**
+ * Bounded XML document response (UBL / CII / Facturae / PEPPOL / FatturaPA /
+ * XRechnung — anything declared `application/xml` or `text/xml`).
+ */
+export interface XmlDocument {
+    /** Echoed id from the request (invoice id). */
+    id: string;
+    /** Strictly decoded UTF-8 XML text. */
+    xml: string;
+    /** Verbatim `Content-Type` from the response. */
+    contentType: string;
+    /** Byte length of the decoded UTF-8 body. */
+    sizeBytes: number;
+    /** Filename hint parsed from `Content-Disposition`, when present. */
+    filename?: string;
+}
+/** `/invoices/:id/xml` serves XML or a Factur-X PDF, depending on storage MIME. */
+export type EInvoiceDocument = XmlDocument | BinaryDocument;
 export declare class FrihetApiError extends Error {
     readonly statusCode: number;
     readonly errorCode: string;
-    constructor(statusCode: number, errorCode: string, message?: string);
+    readonly detail?: string | undefined;
+    constructor(statusCode: number, errorCode: string, message?: string, detail?: string | undefined);
 }
 export interface FrihetClientOptions {
     /**
@@ -23,13 +75,32 @@ export interface FrihetClientOptions {
      * Cloudflare Workers should pass ≤25000 to leave margin under the ~30s limit.
      */
     timeoutMs?: number;
+    /**
+     * Internal second factor for API keys provisioned by Frihet OAuth Workers.
+     * Ordinary dashboard/API keys must omit it. The value is sent only to the
+     * already-normalized API origin and is never included in logs or errors.
+     */
+    oauthServiceSecret?: string;
 }
 export declare class FrihetClient {
     private readonly apiKey;
     private readonly baseUrl;
     private readonly timeoutMs;
+    private readonly oauthServiceSecret?;
     constructor(apiKey: string, baseUrl?: string, options?: FrihetClientOptions);
     private request;
+    /** Fetch a raw response. The caller owns timeout and body consumption. */
+    private fetchRaw;
+    /** Consume one response body without ever retaining more than `maxBytes`. */
+    private readBoundedBody;
+    /**
+     * Bounded document fetch — ONE call, ONE Response, dispatch on Content-Type.
+     *
+     * Success and error bodies use the same bounded reader. The abort timer stays
+     * active until the body is complete, and a normal success performs one GET.
+     * A 429 may retry, matching the generic JSON client path.
+     */
+    private requestDocument;
     private sleep;
     /**
      * Wrapper for endpoints whose backend wraps the payload in a `{ data, meta }`
@@ -46,10 +117,15 @@ export declare class FrihetClient {
      * output schema (id/clientName/items/success all read as `undefined`). This
      * unwraps to `body.data`. Every create/update/action mutation routes through
      * here for exactly this reason; single-object reads (`getInvoice`/…) have since
-     * #64. `deleteX` methods deliberately keep `request` (they return `void` — the
-     * tool discards the body and synthesizes `{ success, id }`, so there is nothing
-     * to unwrap). Only unwraps a non-array-object `data` (see guard below), so an
+     * #64. Most `deleteX` methods keep `request` (they return `void` — the tool
+     * discards the body and synthesizes `{ success, id }`, so there is nothing to
+     * unwrap). `deleteInvoice`/`deleteQuote` are the EXCEPTION and route through
+     * here: their backend answers 204 for a real delete but 200 + `{ data, meta }`
+     * when it soft-CANCELS a non-draft document instead (see those methods).
+     * Only unwraps a non-array-object `data` (see guard below), so an
      * array-`data` list envelope and any non-enveloped body pass through unchanged.
+     * A 204 yields `undefined` from `request`, which falls through untouched — that
+     * `undefined` is what tells the delete tools "destroyed, not cancelled".
      *
      * Only unwraps when the body is an object carrying a `data` property that is
      * itself a (non-array) object — i.e. a genuine single-object envelope. It is
@@ -75,7 +151,21 @@ export declare class FrihetClient {
     getInvoice(id: string): Promise<Record<string, unknown>>;
     createInvoice(data: Record<string, unknown>): Promise<Record<string, unknown>>;
     updateInvoice(id: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
-    deleteInvoice(id: string): Promise<void>;
+    /**
+     * DELETE /invoices/{id} — NOT an unconditional destroy.
+     *
+     * The backend refuses to destroy a non-draft invoice (VeriFactu hash-chain
+     * integrity) and soft-CANCELS it instead, and it distinguishes the two
+     * outcomes on the wire (`publicApi.ts` DELETE branch):
+     *   - 204 No Content            → the draft row was really removed
+     *   - 200 + `{ data: { id, status: 'cancelled', previousStatus,
+     *     cancelledVia }, meta }` → the document still exists, now cancelled
+     *
+     * This used to be typed `Promise<void>` and the body was thrown away, so the
+     * tool reported "deleted successfully" for a document that was still there.
+     * Resolves to the unwrapped soft-cancel payload on 200, `undefined` on 204.
+     */
+    deleteInvoice(id: string): Promise<Record<string, unknown> | undefined>;
     searchInvoices(query: string, params?: {
         limit?: number;
         offset?: number;
@@ -137,7 +227,13 @@ export declare class FrihetClient {
     getQuote(id: string): Promise<Record<string, unknown>>;
     createQuote(data: Record<string, unknown>): Promise<Record<string, unknown>>;
     updateQuote(id: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
-    deleteQuote(id: string): Promise<void>;
+    /**
+     * DELETE /quotes/{id} — same two-outcome contract as {@link deleteInvoice}:
+     * the backend soft-CANCELS a non-draft quote (200 + body), destroys only a
+     * clean draft with no delivery/response/attachment/conversion evidence (204),
+     * and refuses a protected draft with 409.
+     */
+    deleteQuote(id: string): Promise<Record<string, unknown> | undefined>;
     listVendors(params?: {
         q?: string;
         limit?: number;
@@ -151,8 +247,8 @@ export declare class FrihetClient {
     deleteVendor(id: string): Promise<void>;
     sendInvoice(id: string, to?: string): Promise<Record<string, unknown>>;
     markInvoicePaid(id: string, paidDate?: string): Promise<Record<string, unknown>>;
-    getInvoicePdf(id: string): Promise<Record<string, unknown>>;
-    getInvoiceEInvoice(invoiceId: string): Promise<any>;
+    getInvoicePdf(id: string): Promise<BinaryDocument>;
+    getInvoiceEInvoice(invoiceId: string): Promise<EInvoiceDocument>;
     /**
      * `POST /v1/invoices/:id/credit-note` — creates a rectificativa DRAFT.
      *
@@ -176,13 +272,13 @@ export declare class FrihetClient {
         daysOverdue?: number;
     }): Promise<any>;
     sendQuote(id: string, to?: string): Promise<Record<string, unknown>>;
-    listWebhooks(params?: {
-        limit?: number;
-        offset?: number;
-    }): Promise<PaginatedResponse<Record<string, unknown>>>;
-    getWebhook(id: string): Promise<Record<string, unknown>>;
-    createWebhook(data: Record<string, unknown>): Promise<Record<string, unknown>>;
-    updateWebhook(id: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
+    listWebhooks(): Promise<{
+        data: Webhook[];
+        total: number;
+    }>;
+    getWebhook(id: string): Promise<Webhook>;
+    createWebhook(data: CreateWebhookInput): Promise<CreateWebhookResult>;
+    updateWebhook(id: string, data: UpdateWebhookInput): Promise<Webhook>;
     deleteWebhook(id: string): Promise<void>;
     listClientContacts(clientId: string, params?: {
         limit?: number;
@@ -585,7 +681,7 @@ export declare class FrihetClient {
         eventType?: string;
     }): Promise<Record<string, unknown>>;
     exportPayroll(params: {
-        format: "a3" | "contasol" | "sage" | "holded" | "siltra";
+        format: "a3" | "contasol" | "sage" | "siltra";
         month: string;
     }): Promise<Record<string, unknown>>;
     getPayrollChecklist(params: {
@@ -598,7 +694,7 @@ export declare class FrihetClient {
     getPermissionsMatrix(): Promise<Record<string, unknown>>;
     getMyPermissions(): Promise<Record<string, unknown>>;
     getCurrentPeriod(params?: {
-        periodId?: string;
+        fiscalYear?: string;
     }): Promise<Record<string, unknown>>;
     closePeriod(data: {
         type: "monthly" | "quarterly";