@seliseblocks/client 0.1.1 → 0.1.3

package/dist/mail/types.d.ts

@@ -0,0 +1,18 @@
+export type BlocksSendMailRequest = {
+    attachments?: string[];
+    bcc?: string[];
+    bodyDataContext?: Record<string, string>;
+    cc?: string[];
+    language?: string;
+    /** Defaults to the tenant's `x-blocks-key` on the server side when omitted. */
+    projectKey?: string;
+    purpose?: string;
+    replyTo?: string[];
+    sendPhoneNumberAsEmail?: boolean;
+    subjectDataContext?: Record<string, string>;
+    to?: string[];
+};
+export type BlocksSendMailToAnyRequest = BlocksSendMailRequest & {
+    isTestMail?: boolean;
+};
+export type BlocksMailPassThroughResponse = Record<string, unknown>;

package/dist/mail/types.js

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

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

@@ -0,0 +1,89 @@
+import { BlocksHttpClient } from "../http/http-client.js";
+import { BlocksMfaBackupCodeUseRequest, BlocksMfaConfig, BlocksMfaConfigSaveRequest, BlocksMfaGenerateRequest, BlocksMfaPassThroughResponse, BlocksMfaResendRequest, BlocksMfaSetMethodRequest, BlocksMfaVerifyRequest, BlocksMfaVerifyTotpSetupRequest } from "./types.js";
+/**
+ * MFA surface: enroll, verify, switch, or disable the signed-in user's own MFA and manage
+ * their own backup codes, plus `saveConfig` for the tenant-wide MFA policy. Like
+ * `identityProviders`/`config`/`clientCredentials` on `BlocksAuthenticationClient`, `saveConfig`
+ * is an admin/tenant-settings action -- IAM enforces the required role, the SDK does not gate it.
+ */
+export declare class BlocksMfaClient {
+    private readonly http;
+    constructor(http: BlocksHttpClient);
+    /**
+     * What: reads the tenant's current MFA policy through `GET /iam/v4/mfa/config`.
+     * Why: consumer apps can check whether MFA is enabled/required before prompting enrollment.
+     * How: call with an authorized token; the SDK returns IAM's policy shape as-is.
+     */
+    config(): Promise<BlocksMfaConfig>;
+    /**
+     * What: saves the tenant's MFA policy through `POST /iam/v4/mfa/config`.
+     * Why: tenant admin/settings screens need to turn MFA on/off, require it for specific roles,
+     * or configure backup codes -- this is not a user self-service action.
+     * How: pass IAM's full config payload with an authorized, sufficiently-privileged token.
+     */
+    saveConfig(request: BlocksMfaConfigSaveRequest): Promise<BlocksMfaPassThroughResponse>;
+    readonly totp: {
+        /**
+         * What: starts TOTP enrollment through `POST /iam/v4/mfa/totp/setup`.
+         * Why: authenticator-app enrollment needs a secret/QR payload from IAM before the user can scan it.
+         * How: call for the signed-in user, then render IAM's returned secret/QR data in your enrollment UI.
+         */
+        setup: () => Promise<BlocksMfaPassThroughResponse>;
+        /**
+         * What: confirms TOTP enrollment through `POST /iam/v4/mfa/totp/verify-setup`.
+         * Why: IAM must confirm the user's authenticator app is correctly configured before enabling TOTP.
+         * How: pass the 6-digit `code` the user typed from their authenticator app.
+         */
+        verifySetup: (request: BlocksMfaVerifyTotpSetupRequest) => Promise<BlocksMfaPassThroughResponse>;
+    };
+    /**
+     * What: sends an OTP challenge through `POST /iam/v4/mfa/generate`.
+     * Why: email/SMS-based MFA needs IAM to issue and deliver a one-time code before verification.
+     * How: pass the target `mfaType`; IAM returns an `mfaId` to pass to `verify`/`resend`.
+     */
+    generate(request: BlocksMfaGenerateRequest): Promise<BlocksMfaPassThroughResponse>;
+    /**
+     * What: resends a pending OTP through `POST /iam/v4/mfa/resend`.
+     * Why: users may not receive the first code (SMS delay, spam filtering) and need a retry.
+     * How: pass the `mfaId` returned from `generate`.
+     */
+    resend(request: BlocksMfaResendRequest): Promise<BlocksMfaPassThroughResponse>;
+    /**
+     * What: verifies an OTP or step-up challenge through `POST /iam/v4/mfa/verify`.
+     * Why: login and sensitive in-app actions need this to confirm the code the user entered.
+     * How: pass `mfaId`, `verificationCode`, and `authType`; set `isFromTokenCall` when verifying as part of a token/login exchange rather than a standalone check.
+     */
+    verify(request: BlocksMfaVerifyRequest): Promise<BlocksMfaPassThroughResponse>;
+    /**
+     * What: sets the signed-in user's active MFA method through `PUT /iam/v4/mfa/method`.
+     * Why: users who have enrolled more than one method need to switch which one is active.
+     * How: pass the `mfaType` to activate; enroll it first (e.g. via `totp.setup`/`verifySetup`) if it isn't already.
+     */
+    setMethod(request: BlocksMfaSetMethodRequest): Promise<BlocksMfaPassThroughResponse>;
+    /**
+     * What: disables MFA for the signed-in user through `POST /iam/v4/mfa/disable`.
+     * Why: users need a self-service way to turn MFA off when the tenant's policy allows opt-out.
+     * How: call with an authorized token; IAM enforces whether opt-out is permitted for this tenant/role.
+     */
+    disable(): Promise<BlocksMfaPassThroughResponse>;
+    readonly backupCodes: {
+        /**
+         * What: lists the signed-in user's backup codes through `GET /iam/v4/mfa/backup-codes`.
+         * Why: account-security screens need to show how many unused recovery codes remain.
+         * How: call with an authorized token.
+         */
+        list: () => Promise<BlocksMfaPassThroughResponse>;
+        /**
+         * What: generates a fresh set of backup codes through `POST /iam/v4/mfa/backup-codes/generate`.
+         * Why: users need recovery codes for when their primary MFA method is unavailable.
+         * How: call once TOTP/OTP is enrolled; treat the response as sensitive and show it to the user only once.
+         */
+        generate: () => Promise<BlocksMfaPassThroughResponse>;
+        /**
+         * What: consumes one backup code through `POST /iam/v4/mfa/backup-codes/use`.
+         * Why: lets a user complete login/step-up when their primary MFA method is unavailable.
+         * How: pass the signed-in `userId` and the backup `code` the user entered; each code is single-use.
+         */
+        use: (request: BlocksMfaBackupCodeUseRequest) => Promise<BlocksMfaPassThroughResponse>;
+    };
+}

package/dist/mfa/mfa-client.js

@@ -0,0 +1,107 @@
+const MFA_API = "/iam/v4/mfa";
+/**
+ * MFA surface: enroll, verify, switch, or disable the signed-in user's own MFA and manage
+ * their own backup codes, plus `saveConfig` for the tenant-wide MFA policy. Like
+ * `identityProviders`/`config`/`clientCredentials` on `BlocksAuthenticationClient`, `saveConfig`
+ * is an admin/tenant-settings action -- IAM enforces the required role, the SDK does not gate it.
+ */
+export class BlocksMfaClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * What: reads the tenant's current MFA policy through `GET /iam/v4/mfa/config`.
+     * Why: consumer apps can check whether MFA is enabled/required before prompting enrollment.
+     * How: call with an authorized token; the SDK returns IAM's policy shape as-is.
+     */
+    config() {
+        return this.http.request(`${MFA_API}/config`);
+    }
+    /**
+     * What: saves the tenant's MFA policy through `POST /iam/v4/mfa/config`.
+     * Why: tenant admin/settings screens need to turn MFA on/off, require it for specific roles,
+     * or configure backup codes -- this is not a user self-service action.
+     * How: pass IAM's full config payload with an authorized, sufficiently-privileged token.
+     */
+    saveConfig(request) {
+        return this.http.request(`${MFA_API}/config`, { body: request });
+    }
+    totp = {
+        /**
+         * What: starts TOTP enrollment through `POST /iam/v4/mfa/totp/setup`.
+         * Why: authenticator-app enrollment needs a secret/QR payload from IAM before the user can scan it.
+         * How: call for the signed-in user, then render IAM's returned secret/QR data in your enrollment UI.
+         */
+        setup: () => this.http.request(`${MFA_API}/totp/setup`, { method: "POST" }),
+        /**
+         * What: confirms TOTP enrollment through `POST /iam/v4/mfa/totp/verify-setup`.
+         * Why: IAM must confirm the user's authenticator app is correctly configured before enabling TOTP.
+         * How: pass the 6-digit `code` the user typed from their authenticator app.
+         */
+        verifySetup: (request) => this.http.request(`${MFA_API}/totp/verify-setup`, { body: request })
+    };
+    /**
+     * What: sends an OTP challenge through `POST /iam/v4/mfa/generate`.
+     * Why: email/SMS-based MFA needs IAM to issue and deliver a one-time code before verification.
+     * How: pass the target `mfaType`; IAM returns an `mfaId` to pass to `verify`/`resend`.
+     */
+    generate(request) {
+        return this.http.request(`${MFA_API}/generate`, { body: request });
+    }
+    /**
+     * What: resends a pending OTP through `POST /iam/v4/mfa/resend`.
+     * Why: users may not receive the first code (SMS delay, spam filtering) and need a retry.
+     * How: pass the `mfaId` returned from `generate`.
+     */
+    resend(request) {
+        return this.http.request(`${MFA_API}/resend`, { body: request });
+    }
+    /**
+     * What: verifies an OTP or step-up challenge through `POST /iam/v4/mfa/verify`.
+     * Why: login and sensitive in-app actions need this to confirm the code the user entered.
+     * How: pass `mfaId`, `verificationCode`, and `authType`; set `isFromTokenCall` when verifying as part of a token/login exchange rather than a standalone check.
+     */
+    verify(request) {
+        return this.http.request(`${MFA_API}/verify`, { body: request });
+    }
+    /**
+     * What: sets the signed-in user's active MFA method through `PUT /iam/v4/mfa/method`.
+     * Why: users who have enrolled more than one method need to switch which one is active.
+     * How: pass the `mfaType` to activate; enroll it first (e.g. via `totp.setup`/`verifySetup`) if it isn't already.
+     */
+    setMethod(request) {
+        return this.http.request(`${MFA_API}/method`, {
+            body: request,
+            method: "PUT"
+        });
+    }
+    /**
+     * What: disables MFA for the signed-in user through `POST /iam/v4/mfa/disable`.
+     * Why: users need a self-service way to turn MFA off when the tenant's policy allows opt-out.
+     * How: call with an authorized token; IAM enforces whether opt-out is permitted for this tenant/role.
+     */
+    disable() {
+        return this.http.request(`${MFA_API}/disable`, { method: "POST" });
+    }
+    backupCodes = {
+        /**
+         * What: lists the signed-in user's backup codes through `GET /iam/v4/mfa/backup-codes`.
+         * Why: account-security screens need to show how many unused recovery codes remain.
+         * How: call with an authorized token.
+         */
+        list: () => this.http.request(`${MFA_API}/backup-codes`),
+        /**
+         * What: generates a fresh set of backup codes through `POST /iam/v4/mfa/backup-codes/generate`.
+         * Why: users need recovery codes for when their primary MFA method is unavailable.
+         * How: call once TOTP/OTP is enrolled; treat the response as sensitive and show it to the user only once.
+         */
+        generate: () => this.http.request(`${MFA_API}/backup-codes/generate`, { method: "POST" }),
+        /**
+         * What: consumes one backup code through `POST /iam/v4/mfa/backup-codes/use`.
+         * Why: lets a user complete login/step-up when their primary MFA method is unavailable.
+         * How: pass the signed-in `userId` and the backup `code` the user entered; each code is single-use.
+         */
+        use: (request) => this.http.request(`${MFA_API}/backup-codes/use`, { body: request })
+    };
+}

package/dist/mfa/types.d.ts

@@ -0,0 +1,48 @@
+export type BlocksMfaConfig = Record<string, unknown> & {
+    allowBackupCodes?: boolean;
+    allowUserOptOut?: boolean;
+    backupCodesCount?: number;
+    enableMfa?: boolean;
+    requireMfaForAllUsers?: boolean;
+    userMfaType?: number[];
+};
+export type BlocksMfaConfigSaveRequest = Record<string, unknown> & {
+    allowBackupCodes?: boolean;
+    allowUserOptOut?: boolean;
+    backupCodesCount?: number;
+    enableMfa?: boolean;
+    mfaExemptRoles?: string[];
+    mfaRequiredRoles?: string[];
+    mfaTemplate?: {
+        templateId?: string;
+        templateName?: string;
+    };
+    requireMfaForAllUsers?: boolean;
+    userMfaType?: number[];
+};
+export type BlocksMfaGenerateRequest = {
+    /** IAM-defined numeric MFA method (its enum names aren't in the swagger contract -- treat as opaque). */
+    mfaType: number;
+    sendPhoneNumberAsEmailDomain?: string;
+};
+export type BlocksMfaResendRequest = {
+    mfaId: string;
+    sendPhoneNumberAsEmailDomain?: string;
+};
+export type BlocksMfaVerifyRequest = {
+    authType: number;
+    isFromTokenCall?: boolean;
+    mfaId: string;
+    verificationCode: string;
+};
+export type BlocksMfaSetMethodRequest = {
+    mfaType: number;
+};
+export type BlocksMfaVerifyTotpSetupRequest = {
+    code: string;
+};
+export type BlocksMfaBackupCodeUseRequest = {
+    code: string;
+    userId: string;
+};
+export type BlocksMfaPassThroughResponse = Record<string, unknown>;

package/dist/mfa/types.js

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

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

@@ -0,0 +1,43 @@
+import { BlocksHttpClient } from "../http/http-client.js";
+import { BlocksGetNotificationsOptions, BlocksGetNotificationsResponse, BlocksGetUnreadNotificationsBySubscriptionFilterRequest, BlocksMarkNotificationAsReadRequest, BlocksNotifierPassThroughResponse, BlocksNotifyRequest, BlocksOfflineNotification } from "./types.js";
+/**
+ * Real-time/offline notification surface: push a notification to specific users, roles, or
+ * subscription-filter matches, and read/manage the signed-in user's own notification inbox.
+ * Tenant-wide notification *channel configuration* (Notification/Save etc., under
+ * `BlocksIAMClient`/CLI `notification` commands) is a separate, admin-facing concern.
+ */
+export declare class BlocksNotifierClient {
+    private readonly http;
+    constructor(http: BlocksHttpClient);
+    /**
+     * 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.
+     */
+    notify(request: BlocksNotifyRequest): Promise<BlocksNotifierPassThroughResponse>;
+    /**
+     * What: reads unread notifications matching a subscription filter through `GET /logic/v4/Notifier/GetUnreadNotificationsBySubscriptionFilter`.
+     * Why: clients that subscribe by filter (rather than by user id) need to catch up on what they missed while offline.
+     * How: pass `userId` and the same `subscriptionFilterData` shape used with `notify`. Swagger documents this endpoint
+     * as GET with a JSON body, which the Fetch spec forbids -- the SDK sends the same fields as a flattened query string instead.
+     */
+    getUnreadNotificationsBySubscriptionFilter(request: BlocksGetUnreadNotificationsBySubscriptionFilterRequest): Promise<BlocksOfflineNotification[]>;
+    /**
+     * What: lists the signed-in user's notifications through `GET /logic/v4/Notifier/GetNotifications`.
+     * Why: notification-inbox UIs need paged, sortable, filterable access plus unread/total counts.
+     * How: pass paging/sort/filter options; omit them for the API's defaults.
+     */
+    getNotifications(options?: BlocksGetNotificationsOptions): Promise<BlocksGetNotificationsResponse>;
+    /**
+     * What: marks every notification read through `POST /logic/v4/Notifier/MarkAllNotificationAsRead`.
+     * Why: inbox UIs offer a bulk "mark all as read" action.
+     * How: call with an authorized token for the signed-in user.
+     */
+    markAllNotificationAsRead(): Promise<BlocksNotifierPassThroughResponse>;
+    /**
+     * What: marks one notification read through `POST /logic/v4/Notifier/MarkNotificationAsRead`.
+     * Why: inbox UIs mark individual notifications read as the user views them.
+     * How: pass the notification's `id`.
+     */
+    markNotificationAsRead(request: BlocksMarkNotificationAsReadRequest): Promise<BlocksNotifierPassThroughResponse>;
+}

package/dist/notifier/notifier-client.js

@@ -0,0 +1,71 @@
+const NOTIFIER_API = "/logic/v4/Notifier";
+/**
+ * Real-time/offline notification surface: push a notification to specific users, roles, or
+ * subscription-filter matches, and read/manage the signed-in user's own notification inbox.
+ * Tenant-wide notification *channel configuration* (Notification/Save etc., under
+ * `BlocksIAMClient`/CLI `notification` commands) is a separate, admin-facing concern.
+ */
+export class BlocksNotifierClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * 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.
+     */
+    notify(request) {
+        return this.http.request(`${NOTIFIER_API}/Notify`, { body: request });
+    }
+    /**
+     * What: reads unread notifications matching a subscription filter through `GET /logic/v4/Notifier/GetUnreadNotificationsBySubscriptionFilter`.
+     * Why: clients that subscribe by filter (rather than by user id) need to catch up on what they missed while offline.
+     * How: pass `userId` and the same `subscriptionFilterData` shape used with `notify`. Swagger documents this endpoint
+     * as GET with a JSON body, which the Fetch spec forbids -- the SDK sends the same fields as a flattened query string instead.
+     */
+    getUnreadNotificationsBySubscriptionFilter(request) {
+        return this.http.request(`${NOTIFIER_API}/GetUnreadNotificationsBySubscriptionFilter`, {
+            query: {
+                OrderBy: request.orderBy,
+                "SubscriptionFilterData.ActionName": request.subscriptionFilterData?.actionName,
+                "SubscriptionFilterData.Context": request.subscriptionFilterData?.context,
+                "SubscriptionFilterData.Value": request.subscriptionFilterData?.value,
+                UserId: request.userId
+            }
+        });
+    }
+    /**
+     * What: lists the signed-in user's notifications through `GET /logic/v4/Notifier/GetNotifications`.
+     * Why: notification-inbox UIs need paged, sortable, filterable access plus unread/total counts.
+     * How: pass paging/sort/filter options; omit them for the API's defaults.
+     */
+    getNotifications(options = {}) {
+        return this.http.request(`${NOTIFIER_API}/GetNotifications`, {
+            query: {
+                Filter: options.filter,
+                IsUnreadOnly: options.isUnreadOnly,
+                Page: options.page,
+                PageSize: options.pageSize,
+                "Sort.IsDescending": options.sortDescending,
+                "Sort.Property": options.sortBy
+            }
+        });
+    }
+    /**
+     * What: marks every notification read through `POST /logic/v4/Notifier/MarkAllNotificationAsRead`.
+     * Why: inbox UIs offer a bulk "mark all as read" action.
+     * How: call with an authorized token for the signed-in user.
+     */
+    markAllNotificationAsRead() {
+        return this.http.request(`${NOTIFIER_API}/MarkAllNotificationAsRead`, { method: "POST" });
+    }
+    /**
+     * What: marks one notification read through `POST /logic/v4/Notifier/MarkNotificationAsRead`.
+     * Why: inbox UIs mark individual notifications read as the user views them.
+     * How: pass the notification's `id`.
+     */
+    markNotificationAsRead(request) {
+        return this.http.request(`${NOTIFIER_API}/MarkNotificationAsRead`, { body: request });
+    }
+}

package/dist/notifier/types.d.ts

@@ -0,0 +1,50 @@
+export type BlocksNotifierSubscriptionFilter = {
+    actionName?: string;
+    context?: string;
+    value?: string;
+};
+export type BlocksNotifyRequest = {
+    configurationName?: string;
+    connectionId?: string;
+    contentAvailable?: boolean;
+    denormalizedPayload?: string;
+    responseKey?: string;
+    responseValue?: string;
+    roles?: string[];
+    saveDenormalizedPayloadAsAnObject?: boolean;
+    subscriptionFilters?: BlocksNotifierSubscriptionFilter[];
+    userIds?: string[];
+};
+export type BlocksGetUnreadNotificationsBySubscriptionFilterRequest = {
+    /** IAM/Notifier-defined order enum (its meanings aren't in the swagger contract -- treat as opaque). */
+    orderBy?: 1 | 2;
+    subscriptionFilterData?: BlocksNotifierSubscriptionFilter;
+    userId?: string;
+};
+export type BlocksGetNotificationsOptions = {
+    filter?: string;
+    isUnreadOnly?: boolean;
+    page?: number;
+    pageSize?: number;
+    sortBy?: string;
+    sortDescending?: boolean;
+};
+export type BlocksOfflineNotification = Record<string, unknown> & {
+    correlationId?: string;
+    createdTime?: string;
+    denormalizedPayload?: string;
+    id?: string;
+    isRead?: boolean;
+    payload?: string;
+    readByRoles?: string[];
+    readByUserIds?: string[];
+};
+export type BlocksGetNotificationsResponse = {
+    notifications: Record<string, unknown>[];
+    totalNotificationsCount: number;
+    unReadNotificationsCount: number;
+};
+export type BlocksMarkNotificationAsReadRequest = {
+    id: string;
+};
+export type BlocksNotifierPassThroughResponse = Record<string, unknown>;

package/dist/notifier/types.js

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

package/package.json

@@ -1,48 +1,48 @@
-{
-  "name": "@seliseblocks/client",
-  "version": "0.1.1",
-  "description": "Framework-neutral TypeScript client SDK for SELISE Blocks frontend applications.",
-  "license": "MIT",
-  "type": "module",
-  "keywords": [
-    "selise",
-    "blocks",
-    "sdk",
-    "typescript",
-    "frontend"
-  ],
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    },
-    "./package.json": "./package.json"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "sideEffects": false,
-  "files": [
-    "dist",
-    "README.md",
-    "AI_USAGE_GUIDE.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
-    "build": "npm run clean && tsc -p tsconfig.json",
-    "lint": "tsc -p tsconfig.json --noEmit",
-    "test": "npm run build && node --test test/*.test.mjs",
-    "prepack": "npm run build",
-    "prepublishOnly": "npm test"
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "typescript": "^5.5.0"
-  }
-}
+{
+  "name": "@seliseblocks/client",
+  "version": "0.1.3",
+  "description": "Framework-neutral TypeScript client SDK for SELISE Blocks frontend applications.",
+  "license": "MIT",
+  "type": "module",
+  "keywords": [
+    "selise",
+    "blocks",
+    "sdk",
+    "typescript",
+    "frontend"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "AI_USAGE_GUIDE.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run clean && tsc -p tsconfig.json",
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run build && node --test test/*.test.mjs",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm test"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.5.0"
+  }
+}