@seliseblocks/client 0.2.0 → 0.3.0

package/dist/logic/functions-client.js

@@ -0,0 +1,210 @@
+import { BlocksApiError } from "../http/errors.js";
+import { parseBody } from "../http/http-client.js";
+import { trimSlashes } from "./route.js";
+/** The public function route under the API gateway; the management API is CLI-only. */
+const FUNCTION_API = "/logic/v4/fn";
+const TERMINAL = new Set([
+    "SUCCEEDED", "FAILED", "TIMED_OUT", "CANCELLED", "RESOURCE_EXCEEDED", "OUTPUT_FAILED"
+]);
+/** A run that finished without an answer: FAILED, TIMED_OUT, CANCELLED or RESOURCE_EXCEEDED. */
+export class BlocksFunctionRunError extends Error {
+    runId;
+    status;
+    errorCode;
+    errorMessage;
+    constructor(runId, status, errorCode, errorMessage) {
+        super(`Function run ${runId} ended ${status}${errorCode ? ` (${errorCode})` : ""}${errorMessage ? `: ${errorMessage}` : ""}`);
+        this.runId = runId;
+        this.status = status;
+        this.errorCode = errorCode;
+        this.errorMessage = errorMessage;
+        this.name = "BlocksFunctionRunError";
+    }
+}
+/**
+ * Calling deployed Blocks functions from app code. Creating, saving, deploying and
+ * inspecting functions is CLI work (`blocks logic function *`), not exposed here.
+ */
+export class BlocksFunctionsClient {
+    http;
+    apiUrl;
+    constructor(http, apiUrl) {
+        this.http = http;
+        this.apiUrl = apiUrl;
+    }
+    /**
+     * What: the absolute public URL of a function (optionally with a sub-path).
+     * Why: third parties (webhooks, other backends) call the function directly and need its address.
+     * How: callers send this project's `x-blocks-key`, plus a Blocks bearer token unless the trigger is Public.
+     */
+    url(functionId, path) {
+        return `${this.apiUrl}${routeOf(functionId, path)}`;
+    }
+    /**
+     * What: invokes a deployed function and returns either its answer or the queued run.
+     * Why: functions run async (202 + poll token) unless deployed as sync, and callers need to know which happened.
+     * How: `kind: "answered"` carries the function's own status/headers/body; `kind: "accepted"` carries
+     * `runId` + `pollToken` for `waitForResult`. Any non-2xx is thrown as `BlocksApiError` -- the platform's
+     * refusals (`FUNCTION_INVOKE_*` codes: 401/403/404/405/413/429/503), a failed or timed-out sync run
+     * (502/504 with `runId`), and a status the function chose itself. Use `call` for just the value.
+     */
+    async invoke(functionId, options = {}) {
+        const response = await this.invokeRaw(functionId, options);
+        const body = await parseBody(response);
+        if (!response.ok)
+            throw new BlocksApiError(response.status, response.statusText, body);
+        if (response.status === 202 && isRecord(body) && typeof body.runId === "string") {
+            const accepted = {
+                kind: "accepted",
+                status: 202,
+                runId: body.runId,
+                runStatus: String(body.status ?? "QUEUED")
+            };
+            if (typeof body.pollToken === "string")
+                accepted.pollToken = body.pollToken;
+            return accepted;
+        }
+        const runId = response.headers.get("x-blocks-run-id") ?? undefined;
+        return { kind: "answered", status: response.status, headers: response.headers, body: body, ...(runId ? { runId } : {}) };
+    }
+    /**
+     * What: invokes a function and returns the unread `Response`.
+     * Why: a streaming function (an `async function*` handler) sends its pieces as they come; reading
+     * them needs the body stream, which `invoke` buffers.
+     * How: same request as `invoke`. Pass `headers: { Accept: "text/event-stream" }` for Server-Sent
+     * Events (`data:` per piece, then `event: done` or `event: error`); otherwise the pieces arrive as
+     * chunked text. Never throws on a non-2xx status -- check `response.ok`.
+     */
+    invokeRaw(functionId, options = {}) {
+        const headers = new Headers(options.headers);
+        if (!headers.has("Accept"))
+            headers.set("Accept", "application/json");
+        const prefer = [
+            options.respondAsync ? "respond-async" : undefined,
+            options.waitSeconds !== undefined ? `wait=${Math.max(0, Math.floor(options.waitSeconds))}` : undefined
+        ].filter(Boolean);
+        if (prefer.length > 0)
+            headers.set("Prefer", prefer.join(", "));
+        return this.http.send(routeOf(functionId, options.path), {
+            auth: options.auth,
+            body: options.body,
+            headers,
+            method: options.method ?? "POST",
+            query: options.query,
+            signal: options.signal
+        });
+    }
+    /**
+     * What: reads a queued run's status and, once it finished, its result.
+     * Why: an async invocation answers 202 at once; this is how its outcome is collected.
+     * How: pass the `runId` and `pollToken` from the 202. No user session is needed -- the token is
+     * the capability -- and any wrong, expired or foreign token is the same 404.
+     */
+    async getResult(runId, pollToken, options = {}) {
+        const response = await this.http.send(`${FUNCTION_API}/runs/${encodeURIComponent(runId)}/result`, {
+            auth: false,
+            headers: { Accept: "application/json", "x-poll-token": pollToken },
+            signal: options.signal
+        });
+        const body = await parseBody(response);
+        if (!response.ok)
+            throw new BlocksApiError(response.status, response.statusText, body);
+        return body;
+    }
+    /**
+     * What: the full run record (input, result, attempts, timings) for a signed-in caller.
+     * Why: an admin screen or a caller without a poll token may need the whole run.
+     * How: requires the `blocks-logic::function::read` permission; reads within the caller's own tenant.
+     */
+    getRun(runId) {
+        return this.http.request(`${FUNCTION_API}/runs/${encodeURIComponent(runId)}`);
+    }
+    /**
+     * What: polls a queued run until it finishes.
+     * Why: turns the 202 + poll token into the final outcome without hand-written polling.
+     * How: resolves with the terminal `BlocksFunctionRunResult` (check `status`); rejects on `timeoutMs`
+     * (the run itself keeps going) or `signal` abort.
+     */
+    async waitForResult(accepted, options = {}) {
+        if (!accepted.pollToken) {
+            throw new Error(`Run ${accepted.runId} has no poll token; read it with getRun() (needs function::read) instead.`);
+        }
+        const interval = options.intervalMs ?? 1000;
+        const deadline = Date.now() + (options.timeoutMs ?? 60_000);
+        for (;;) {
+            const result = await this.getResult(accepted.runId, accepted.pollToken, { signal: options.signal });
+            if (TERMINAL.has(result.status))
+                return result;
+            if (Date.now() + interval > deadline) {
+                throw new Error(`Run ${accepted.runId} is still ${result.status}; stopped waiting (the run continues).`);
+            }
+            await delay(interval, options.signal);
+        }
+    }
+    /**
+     * What: invokes a function and returns its value, however it was deployed.
+     * Why: most callers want the handler's return value, not the transport details.
+     * How: a sync answer's body is returned as is; an async run is awaited and its result parsed. A
+     * returned `{ statusCode, headers, body }` is unwrapped to `body` (a 4xx/5xx `statusCode` throws
+     * `BlocksApiError`). A run that fails throws `BlocksFunctionRunError`.
+     */
+    async call(functionId, options = {}) {
+        const outcome = await this.invoke(functionId, options);
+        if (outcome.kind === "answered")
+            return outcome.body;
+        const run = await this.waitForResult(outcome, options);
+        if (run.status !== "SUCCEEDED" && run.status !== "OUTPUT_FAILED") {
+            throw new BlocksFunctionRunError(run.runId, run.status, run.errorCode, run.errorMessage);
+        }
+        const value = parseResult(run.result);
+        if (isHttpResponseShape(value)) {
+            if (value.statusCode >= 400)
+                throw new BlocksApiError(value.statusCode, "", value.body);
+            return value.body;
+        }
+        return value;
+    }
+}
+function routeOf(functionId, path) {
+    if (!functionId)
+        throw new Error("A function id is required.");
+    const suffix = trimSlashes(path ?? "");
+    const root = `${FUNCTION_API}/${encodeURIComponent(functionId)}`;
+    return suffix ? `${root}/${suffix}` : root;
+}
+function parseResult(result) {
+    if (result === null || result === undefined || result === "")
+        return undefined;
+    try {
+        return JSON.parse(result);
+    }
+    catch {
+        return result;
+    }
+}
+/** The handler's HTTP-answer shape (`FunctionHttpResponse`): `statusCode` plus only `headers`/`body`. */
+function isHttpResponseShape(value) {
+    if (!isRecord(value) || typeof value.statusCode !== "number")
+        return false;
+    return Object.keys(value).every((key) => key === "statusCode" || key === "headers" || key === "body");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function delay(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(signal.reason ?? new Error("Aborted"));
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(signal?.reason ?? new Error("Aborted"));
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}

package/dist/logic/logic-client.d.ts

@@ -0,0 +1,13 @@
+import { BlocksHttpClient } from "../http/http-client.js";
+import { BlocksFunctionsClient } from "./functions-client.js";
+import { BlocksProxyClient } from "./proxy-client.js";
+/**
+ * blocks-logic runtime surface for app code: invoking deployed functions and calling
+ * third-party APIs through proxies. Authoring and administering both -- and workflows,
+ * schedules -- is CLI work.
+ */
+export declare class BlocksLogicClient {
+    readonly functions: BlocksFunctionsClient;
+    readonly proxy: BlocksProxyClient;
+    constructor(http: BlocksHttpClient, apiUrl: string);
+}

package/dist/logic/logic-client.js

@@ -0,0 +1,15 @@
+import { BlocksFunctionsClient } from "./functions-client.js";
+import { BlocksProxyClient } from "./proxy-client.js";
+/**
+ * blocks-logic runtime surface for app code: invoking deployed functions and calling
+ * third-party APIs through proxies. Authoring and administering both -- and workflows,
+ * schedules -- is CLI work.
+ */
+export class BlocksLogicClient {
+    functions;
+    proxy;
+    constructor(http, apiUrl) {
+        this.functions = new BlocksFunctionsClient(http, apiUrl);
+        this.proxy = new BlocksProxyClient(http, apiUrl);
+    }
+}

package/dist/logic/proxy-client.d.ts

@@ -0,0 +1,33 @@
+import { BlocksHttpClient } from "../http/http-client.js";
+import { BlocksProxyRequestOptions } from "./types.js";
+/**
+ * Calling a third-party API through a Blocks proxy, so the upstream URL and its
+ * credentials stay server-side.
+ */
+export declare class BlocksProxyClient {
+    private readonly http;
+    private readonly apiUrl;
+    constructor(http: BlocksHttpClient, apiUrl: string);
+    /**
+     * What: the absolute gateway URL of a proxy route.
+     * Why: other backends and tools call the proxy directly.
+     * How: callers send this project's `x-blocks-key`, plus a Blocks bearer token unless the proxy is Public.
+     */
+    url(slug: string, path?: string): string;
+    /**
+     * What: calls the upstream through the proxy and returns the parsed response body.
+     * Why: app code reaches a third-party API without holding its URL or keys.
+     * How: `method` (default GET) must be one the proxy allows and `path` must match a declared route.
+     * Non-2xx -- the upstream's own errors, and gateway refusals with `PROXY_GATEWAY_<OUTCOME>` codes
+     * (401 no/invalid token, 403 access rules or undeclared route, 404 unknown or disabled proxy, 405
+     * method not allowed, 413 body over 1 MB, 422 body not mergeable, 429 rate limit with
+     * `Retry-After`, 502/503/504 upstream failure/unavailable/timeout) -- throws `BlocksApiError`.
+     */
+    request<T = unknown>(slug: string, options?: BlocksProxyRequestOptions): Promise<T>;
+    /**
+     * What: the same call, returning the unread `Response`.
+     * Why: for non-JSON upstream bodies (files, streams) or when headers such as `Retry-After` matter.
+     * How: never throws on a non-2xx status -- check `response.ok`.
+     */
+    requestRaw(slug: string, options?: BlocksProxyRequestOptions): Promise<Response>;
+}

package/dist/logic/proxy-client.js

@@ -0,0 +1,64 @@
+import { trimSlashes } from "./route.js";
+/** A proxy's public gateway route; configuring proxies is CLI work (`blocks logic proxy *`). */
+const PROXY_GATEWAY_API = "/logic/v4/proxy/gateway";
+/**
+ * Calling a third-party API through a Blocks proxy, so the upstream URL and its
+ * credentials stay server-side.
+ */
+export class BlocksProxyClient {
+    http;
+    apiUrl;
+    constructor(http, apiUrl) {
+        this.http = http;
+        this.apiUrl = apiUrl;
+    }
+    /**
+     * What: the absolute gateway URL of a proxy route.
+     * Why: other backends and tools call the proxy directly.
+     * How: callers send this project's `x-blocks-key`, plus a Blocks bearer token unless the proxy is Public.
+     */
+    url(slug, path) {
+        return `${this.apiUrl}${routeOf(slug, path)}`;
+    }
+    /**
+     * What: calls the upstream through the proxy and returns the parsed response body.
+     * Why: app code reaches a third-party API without holding its URL or keys.
+     * How: `method` (default GET) must be one the proxy allows and `path` must match a declared route.
+     * Non-2xx -- the upstream's own errors, and gateway refusals with `PROXY_GATEWAY_<OUTCOME>` codes
+     * (401 no/invalid token, 403 access rules or undeclared route, 404 unknown or disabled proxy, 405
+     * method not allowed, 413 body over 1 MB, 422 body not mergeable, 429 rate limit with
+     * `Retry-After`, 502/503/504 upstream failure/unavailable/timeout) -- throws `BlocksApiError`.
+     */
+    request(slug, options = {}) {
+        return this.http.request(routeOf(slug, options.path), {
+            auth: options.auth,
+            body: options.body,
+            headers: options.headers,
+            method: options.method ?? "GET",
+            query: options.query,
+            signal: options.signal
+        });
+    }
+    /**
+     * What: the same call, returning the unread `Response`.
+     * Why: for non-JSON upstream bodies (files, streams) or when headers such as `Retry-After` matter.
+     * How: never throws on a non-2xx status -- check `response.ok`.
+     */
+    requestRaw(slug, options = {}) {
+        return this.http.send(routeOf(slug, options.path), {
+            auth: options.auth,
+            body: options.body,
+            headers: options.headers,
+            method: options.method ?? "GET",
+            query: options.query,
+            signal: options.signal
+        });
+    }
+}
+function routeOf(slug, path) {
+    if (!slug)
+        throw new Error("A proxy slug is required.");
+    const suffix = trimSlashes(path ?? "");
+    const root = `${PROXY_GATEWAY_API}/${encodeURIComponent(slug)}`;
+    return suffix ? `${root}/${suffix}` : root;
+}

package/dist/logic/route.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Drops leading and trailing `/` from a caller-supplied sub-path. A loop rather than
+ * `/^\/+|\/+$/g`: that pattern backtracks quadratically on a long run of slashes that
+ * does not end the string, and the path comes straight from app code.
+ */
+export declare function trimSlashes(value: string): string;

package/dist/logic/route.js

@@ -0,0 +1,14 @@
+/**
+ * Drops leading and trailing `/` from a caller-supplied sub-path. A loop rather than
+ * `/^\/+|\/+$/g`: that pattern backtracks quadratically on a long run of slashes that
+ * does not end the string, and the path comes straight from app code.
+ */
+export function trimSlashes(value) {
+    let start = 0;
+    let end = value.length;
+    while (start < end && value[start] === "/")
+        start++;
+    while (end > start && value[end - 1] === "/")
+        end--;
+    return value.slice(start, end);
+}

package/dist/logic/types.d.ts

@@ -0,0 +1,95 @@
+export type BlocksHttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export type BlocksQueryValue = boolean | number | string | ReadonlyArray<boolean | number | string>;
+/** One call to a function's public route. */
+export type BlocksFunctionInvokeOptions = {
+    /**
+     * Request body. A plain value is sent as JSON; a `Blob`, `FormData`, `URLSearchParams`,
+     * `ArrayBuffer` or stream is sent as is. The handler sees it as `input.body`.
+     */
+    body?: unknown;
+    /**
+     * Extra request headers. The handler only sees an allow-list (content type, request ids,
+     * known webhook-signature headers) -- send app data in the body or query, not custom headers.
+     */
+    headers?: HeadersInit;
+    /** Defaults to POST. The trigger refuses verbs it does not list with 405. */
+    method?: BlocksHttpMethod;
+    /** Sub-path after the function id, passed to the handler as `input.path` (`orders/42`). */
+    path?: string;
+    query?: Record<string, BlocksQueryValue | undefined>;
+    /**
+     * Send the signed-in user's token (default true). A Token trigger needs it; pass
+     * `false` for a Public function called from a page with no session.
+     */
+    auth?: boolean;
+    /**
+     * Ask for the 202 + poll token even when the function is deployed as synchronous
+     * (`Prefer: respond-async`).
+     */
+    respondAsync?: boolean;
+    /**
+     * For a synchronous function, wait at most this many seconds for the answer
+     * (`Prefer: wait=<n>`); the platform caps the wait at ~30 s regardless. A call that
+     * outlives the wait is answered 202 + poll token, and the run still finishes.
+     */
+    waitSeconds?: number;
+    signal?: AbortSignal;
+};
+/** The run was queued and has not finished: collect it with `getResult`/`waitForResult`. */
+export type BlocksFunctionAccepted = {
+    kind: "accepted";
+    status: 202;
+    runId: string;
+    /** Wire status: QUEUED, CLAIMED, STARTING, RUNNING or OUTPUT_PROCESSING. */
+    runStatus: string;
+    /**
+     * One-time capability for `getResult`. Absent only if the platform could not issue
+     * one; a caller with `function::read` can still use `getRun`.
+     */
+    pollToken?: string;
+};
+/** The function answered within the request (sync trigger), or the platform answered for it. */
+export type BlocksFunctionAnswer<T = unknown> = {
+    kind: "answered";
+    status: number;
+    headers: Headers;
+    /** Parsed JSON when it parses, otherwise the text. */
+    body: T;
+    /** From `x-blocks-run-id` when the platform set it. */
+    runId?: string;
+};
+export type BlocksFunctionInvokeResult<T = unknown> = BlocksFunctionAccepted | BlocksFunctionAnswer<T>;
+/** Wire statuses a run ends in. */
+export type BlocksFunctionTerminalStatus = "SUCCEEDED" | "FAILED" | "TIMED_OUT" | "CANCELLED" | "RESOURCE_EXCEEDED" | "OUTPUT_FAILED";
+/** What the poll route reports: status, and once finished, the outcome. Never the input. */
+export type BlocksFunctionRunResult = {
+    runId: string;
+    /** Wire status, e.g. RUNNING or SUCCEEDED. */
+    status: string;
+    /** The handler's return value as JSON text, once the run has finished. */
+    result?: string | null;
+    errorCode?: string | null;
+    errorMessage?: string | null;
+};
+export type BlocksFunctionWaitOptions = {
+    /** Delay between polls. Default 1000 ms. */
+    intervalMs?: number;
+    /** Give up after this long. Default 60 000 ms; the run itself keeps going. */
+    timeoutMs?: number;
+    signal?: AbortSignal;
+};
+export type BlocksFunctionCallOptions = BlocksFunctionInvokeOptions & BlocksFunctionWaitOptions;
+/** One call through a proxy's gateway route. */
+export type BlocksProxyRequestOptions = {
+    /** JSON-serialized unless it is already a `BodyInit`. */
+    body?: unknown;
+    headers?: HeadersInit;
+    /** Defaults to GET. Must be one of the proxy's methods and match a declared route. */
+    method?: BlocksHttpMethod;
+    /** Route after the slug (`charges/ch_1`), matched against the proxy's declared routes. */
+    path?: string;
+    query?: Record<string, BlocksQueryValue | undefined>;
+    /** Send the signed-in user's token (default true). Pass `false` for a Public proxy. */
+    auth?: boolean;
+    signal?: AbortSignal;
+};

package/dist/logic/types.js

@@ -0,0 +1 @@
+export {};

package/dist/notifier/notifier-client.d.ts

@@ -12,7 +12,12 @@ export declare class BlocksNotifierClient {
     /**
      * What: pushes a notification through `POST /logic/v4/Notifier/Notify`.
      * Why: app code needs to notify specific users/roles, or everyone subscribed to a filter, in real time with an offline/persisted fallback.
-     * How: target with at least one of `userIds`/`roles`/`subscriptionFilters`; set `saveDenormalizedPayloadAsAnObject` if `denormalizedPayload` is a JSON string clients should receive parsed.
+     * How: name a `configurationName` from the tenant's notification configurations, target with at least one of
+     * `userIds`/`roles`/`organizationIds`/`subscriptionFilters`, and pass `denormalizedPayload`; set
+     * `saveDenormalizedPayloadAsAnObject` if it is a JSON string clients should receive parsed. `connectionId`,
+     * `responseKey` and `responseValue` -- required strings server-side -- are filled with defaults when omitted.
+     * Call it as a signed-in user whose role has `blocks-logic::notifier::send`: since 2026-10-24 blocks-logic
+     * refuses a send (401) that has neither that permission nor the services' internal sender secret.
      */
     notify(request: BlocksNotifyRequest): Promise<BlocksNotifierPassThroughResponse>;
     /**

package/dist/notifier/notifier-client.js

@@ -13,10 +13,16 @@ export class BlocksNotifierClient {
     /**
      * What: pushes a notification through `POST /logic/v4/Notifier/Notify`.
      * Why: app code needs to notify specific users/roles, or everyone subscribed to a filter, in real time with an offline/persisted fallback.
-     * How: target with at least one of `userIds`/`roles`/`subscriptionFilters`; set `saveDenormalizedPayloadAsAnObject` if `denormalizedPayload` is a JSON string clients should receive parsed.
+     * How: name a `configurationName` from the tenant's notification configurations, target with at least one of
+     * `userIds`/`roles`/`organizationIds`/`subscriptionFilters`, and pass `denormalizedPayload`; set
+     * `saveDenormalizedPayloadAsAnObject` if it is a JSON string clients should receive parsed. `connectionId`,
+     * `responseKey` and `responseValue` -- required strings server-side -- are filled with defaults when omitted.
+     * Call it as a signed-in user whose role has `blocks-logic::notifier::send`: since 2026-10-24 blocks-logic
+     * refuses a send (401) that has neither that permission nor the services' internal sender secret.
      */
     notify(request) {
-        return this.http.request(`${NOTIFIER_API}/Notify`, { body: request });
+        const body = { connectionId: "server", responseKey: "notification", responseValue: "notification", ...request };
+        return this.http.request(`${NOTIFIER_API}/Notify`, { body });
     }
     /**
      * What: reads unread notifications matching a subscription filter through `GET /logic/v4/Notifier/GetUnreadNotificationsBySubscriptionFilter`.

package/dist/notifier/types.d.ts

@@ -4,11 +4,21 @@ export type BlocksNotifierSubscriptionFilter = {
     value?: string;
 };
 export type BlocksNotifyRequest = {
-    configurationName?: string;
+    /**
+     * The `name` of one of the tenant's notification configurations (created in the portal or
+     * with `blocks notification save`); it decides the channel and who may receive. Required.
+     */
+    configurationName: string;
+    /** The sender's own SignalR connection. Defaults to `"server"` -- a server-side send has none. */
     connectionId?: string;
     contentAvailable?: boolean;
-    denormalizedPayload?: string;
+    /** The notification content, usually a JSON string. Required by the service. */
+    denormalizedPayload: string;
+    /** Members of these organizations receive it. */
+    organizationIds?: string[];
+    /** Label stored on the notification. Defaults to `"notification"`. */
     responseKey?: string;
+    /** Label stored on the notification. Defaults to `"notification"`. */
     responseValue?: string;
     roles?: string[];
     saveDenormalizedPayloadAsAnObject?: boolean;

package/dist/types.d.ts

@@ -4,7 +4,9 @@ export type BlocksRequestOptions = {
     body?: unknown;
     headers?: HeadersInit;
     method?: string;
-    query?: Record<string, boolean | number | string | undefined>;
+    /** A repeated key is an array (`?tag=a&tag=b`). */
+    query?: Record<string, boolean | number | string | ReadonlyArray<boolean | number | string> | undefined>;
+    signal?: AbortSignal;
 };
 export type BlocksExternalRequestOptions = {
     body?: BodyInit | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seliseblocks/client",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Framework-neutral TypeScript client SDK for SELISE Blocks frontend applications.",
   "license": "MIT",
   "type": "module",
@@ -28,6 +28,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./functions": {
+      "types": "./dist/functions.d.ts",
+      "import": "./dist/functions.js"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {