iom-sdk 0.1.18 → 0.2.3

package/dist/services/fileStorage/file-storage-client.d.ts

@@ -0,0 +1,68 @@
+/**
+ * File storage service client.
+ *
+ * Orchestrates: init → (single-shot PUT | parallel part PUTs) → complete.
+ *
+ * Design notes:
+ *   - **`fetch` (not axios) for S3 PUTs.** Axios attaches request interceptors
+ *     in the parent `Client` that add `Authorization: Bearer …`. That header
+ *     invalidates an S3 presignature. Using `fetch` (no interceptors) makes
+ *     accidental JWT leakage to S3 mechanically impossible.
+ *   - **Blob body, never `arrayBuffer()`.** Passing a `Blob` to `fetch` lets
+ *     the browser stream the bytes. Calling `await partBlob.arrayBuffer()`
+ *     would materialize each part into a fresh `ArrayBuffer`, doubling peak
+ *     memory per active part.
+ *   - **URLs come from the init response, not a separate `/part-urls` call.**
+ *     Backend pre-signs all parts up front. Refresh is on-demand for the
+ *     subset that expires.
+ *   - **`partSize` comes from the init response** — never hardcoded. When the
+ *     backend later tiers part size by file size, this SDK is unaffected.
+ *   - **Per-part retry with exponential backoff + jitter** for transient
+ *     5xx/408/429/network. Distinct from S3-403 expiry which uses
+ *     `refreshUploadUrls` then retries.
+ *   - **Proactive URL refresh at T-60s.** When the per-batch `expiresAt`
+ *     approaches, refresh the URLs of any still-pending parts in one call.
+ *   - **Progress throttled to ~10 Hz**, monotonic (max prev/next). Prevents
+ *     React re-render storms when 6 parts emit progress concurrently.
+ */
+import { AxiosInstance } from 'axios';
+import { ServiceConfig, ErrorHandlingConfig } from '../../config';
+import { CompletedPart, DownloadUrlResponse, FileMetadataResponseDTO, FileStorageCompleteResponseDTO, FileStorageInitDTO, FileStorageInitResponseDTO, PreviewUrlResponse, RequestOptions, UploadFileInput } from '../../types';
+import { Sha256Hasher } from './sha256-worker';
+export declare class FileStorageServiceClient {
+    private axios;
+    /** Override in tests / mock client. */
+    private hasherFactory;
+    constructor(_config: ServiceConfig, _errorHandling: ErrorHandlingConfig, axios: AxiosInstance, 
+    /** Override in tests / mock client. */
+    hasherFactory?: () => Sha256Hasher);
+    initUpload(body: FileStorageInitDTO, opts?: RequestOptions): Promise<FileStorageInitResponseDTO>;
+    /**
+     * Refresh presigned URLs for an in-flight upload. Pass `partNumbers` to
+     * refresh only specific parts (response `urls` come back in the same
+     * order). Pass nothing / empty to refresh all parts.
+     *
+     * Returns the full init-response shape — `uploadId`, `fileReference`,
+     * `urls`, `partSize`, `expiresAt`. The session and part numbers are
+     * preserved; only the URLs (and the `expiresAt` TTL) change.
+     */
+    refreshUploadUrls(uploadId: string, partNumbers?: number[], opts?: RequestOptions): Promise<FileStorageInitResponseDTO>;
+    completeUpload(uploadId: string, parts: CompletedPart[], opts?: RequestOptions): Promise<FileStorageCompleteResponseDTO>;
+    /**
+     * Best-effort abort with a 2s timeout. Never throws — callers (cancel paths,
+     * `pagehide`) shouldn't be blocked by a failing cleanup call. The backend
+     * relies on the S3 lifecycle rule `AbortIncompleteMultipartUpload` to
+     * reclaim storage if this call doesn't reach the server.
+     */
+    abortUpload(uploadId: string): Promise<void>;
+    getMetadata(fileReference: string, opts?: RequestOptions): Promise<FileMetadataResponseDTO>;
+    /**
+     * Soft-delete a file. Status flips to `DELETED`, bytes stay in the bucket,
+     * preview/download return 404. There is intentionally no hard delete.
+     */
+    softDelete(fileReference: string, opts?: RequestOptions): Promise<void>;
+    getPreviewUrl(fileReference: string, opts?: RequestOptions): Promise<PreviewUrlResponse>;
+    getDownloadUrl(fileReference: string): DownloadUrlResponse;
+    uploadFile(input: UploadFileInput): Promise<FileStorageCompleteResponseDTO>;
+    private runMultipart;
+}

package/dist/services/fileStorage/index.d.ts

@@ -0,0 +1,3 @@
+export { FileStorageServiceClient } from './file-storage-client';
+export { createSha256Hasher } from './sha256-worker';
+export type { Sha256Hasher } from './sha256-worker';

package/dist/services/fileStorage/sha256-worker.d.ts

@@ -0,0 +1,13 @@
+export interface Sha256Hasher {
+    /** Full-file SHA-256 as lowercase hex (for `InitUploadRequest.sha256`). */
+    hashFullFile(blob: Blob, signal?: AbortSignal): Promise<string>;
+    /** Per-part SHA-256 as base64 (for `x-amz-checksum-sha256` header). */
+    hashPart(blob: Blob, signal?: AbortSignal): Promise<string>;
+    /** Idempotent. Frees any worker resources when called. */
+    dispose(): void;
+}
+/**
+ * Factory — returns a hasher implementation. Today always main-thread;
+ * once the worker is wired up, this picks based on `typeof Worker`.
+ */
+export declare function createSha256Hasher(): Sha256Hasher;

package/dist/services/fileStorage/sha256.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Hash a Blob to lowercase hex.
+ *
+ * Reads the blob in 1 MiB chunks. The `AbortSignal` is honored between chunks;
+ * mid-chunk aborts wait for the active read to settle (cheap — chunks are 1 MiB).
+ */
+export declare function sha256Hex(blob: Blob, options?: {
+    signal?: AbortSignal;
+}): Promise<string>;
+/**
+ * Hash a Blob to base64 (the encoding S3 expects in `x-amz-checksum-sha256`).
+ *
+ * `hash-wasm` returns hex; we convert at the end. Cheaper than a separate
+ * binary digest because the final digest is only 32 bytes.
+ */
+export declare function sha256Base64(blob: Blob, options?: {
+    signal?: AbortSignal;
+}): Promise<string>;
+/** Convert a hex string (any case) to base64 without intermediate allocations. */
+export declare function hexToBase64(hex: string): string;

package/dist/services/index.d.ts

@@ -7,3 +7,4 @@ export * from './registry';
 export * from './node';
 export * from './up';
 export * from './user';
+export * from './fileStorage';

package/dist/services/node/node-client.d.ts

@@ -1,7 +1,7 @@
 import { AxiosInstance } from 'axios';
 import { ServiceConfig, ErrorHandlingConfig } from '../../config';
 import { RegistryServiceClient } from '../registry/registry-client';
-import { UUID, UUObjectDTO, UUPropertyDTO, UUPropertyValueDTO, UUStatementDTO, UUFileDTO, UUFileFindRequestDTO, UUAddressDTO, QueryParams, UUStatementsAccessFindDTO, AggregateCreateDTO, AggregateEntity, AggregateFindDTO, PageAggregateEntity, ApiResponse, RequestOptions, GroupCreateDTO, GroupAddRecordsDTO, GroupListParams, GroupRecord, PageImplGroupFullDTO, UUMathFormulaDTO, UUMathFormulaCalcDTO, UUMathFormulaFindDTO, UUMathFormulaCalcFindDTO } from '../../types';
+import { UUID, UUObjectDTO, UUPropertyDTO, UUPropertyValueDTO, UUStatementDTO, UUFileDTO, UUAddressDTO, QueryParams, NodeFindRequestDTO, UUStatementsAccessFindDTO, AggregateCreateDTO, AggregateEntity, AggregateFindDTO, PageAggregateEntity, ApiResponse, RequestOptions, GroupCreateDTO, GroupAddRecordsDTO, GroupListParams, PageImplGroupFullDTO, PageImplGroupRecord, UUMathFormulaDTO, UUMathFormulaCalcDTO, UUMathFormulaCalcFindDTO, NodeFindDTO, PageUUMathFormula } from '../../types';
 export declare class NodeServiceClient {
     private errorHandling;
     private axios;
@@ -20,7 +20,6 @@ export declare class NodeServiceClient {
     softDeleteProperty(uuid: UUID): Promise<{
         success: boolean;
     }>;
-    getPropertyValues(params?: QueryParams, options?: RequestOptions): Promise<UUPropertyValueDTO[]>;
     createOrUpdatePropertyValue(value: UUPropertyValueDTO): Promise<UUPropertyValueDTO>;
     createPropertyValue(value: Omit<UUPropertyValueDTO, 'uuid'>): Promise<UUPropertyValueDTO>;
     softDeletePropertyValue(uuid: UUID): Promise<{
@@ -44,30 +43,25 @@ export declare class NodeServiceClient {
     softDeleteStatement(subject: UUID, predicate: string, object: UUID): Promise<{
         success: boolean;
     }>;
-    getFiles(params?: QueryParams, options?: RequestOptions): Promise<UUFileDTO[]>;
     /**
-     * Create or update a UUFile record.
-     * POST /api/UUFile — send binary bytes via `fileContentBase64`. The server
-     * determines `size` and ignores `contentType` / `fileReference` logic.
+     * Create or update a UUFile record (metadata only).
+     *
+     * Bytes-in-Mongo is gone. For first-party uploads, run
+     * `client.fileStorage.uploadFile(...)` first and pass the returned
+     * `fileReference` here along with `fileName`, `contentType`, and `size`.
+     * For external URL attachments, pass the URL as `fileReference`.
      */
     createOrUpdateFile(file: UUFileDTO): Promise<UUFileDTO>;
-    getFile(uuid: UUID, options?: RequestOptions): Promise<UUFileDTO>;
     /**
      * Find UUFile records via POST /api/UUFile/find.
-     * Set `includeFileContentBase64=true` + `nodeFind.uuid` with
-     * `softDeleted=false` to receive the file bytes in `fileContentBase64`.
-     * Otherwise content is always excluded from the response.
+     * Returns metadata only — bytes are served by the FileStorage service via
+     * `client.fileStorage.getPreviewUrl(fileReference)` /
+     * `getDownloadUrl(fileReference)`.
      */
-    findFiles(body: UUFileFindRequestDTO, options?: RequestOptions): Promise<UUFileDTO[]>;
-    /**
-     * Fetch a single file's base64 content by UUID.
-     * Returns null if the file is not found or has no content.
-     */
-    getFileContent(uuid: UUID, options?: RequestOptions): Promise<string | null>;
+    findFiles(body: NodeFindRequestDTO, options?: RequestOptions): Promise<UUFileDTO[]>;
     softDeleteFile(uuid: UUID): Promise<{
         success: boolean;
     }>;
-    getAddresses(params?: QueryParams, options?: RequestOptions): Promise<UUAddressDTO[]>;
     createOrUpdateAddress(address: UUAddressDTO): Promise<UUAddressDTO>;
     createAddress(address: Omit<UUAddressDTO, 'uuid'>): Promise<UUAddressDTO>;
     softDeleteAddress(uuid: UUID): Promise<{
@@ -88,18 +82,6 @@ export declare class NodeServiceClient {
         contentType?: string;
         size?: number;
     }): Promise<ApiResponse<UUFileDTO | null>>;
-    /**
-     * Upload a file's binary content directly.
-     * Complete flow:
-     * 1) Create UUID for the file
-     * 2) Encode file bytes as base64 and POST to /api/UUFile
-     * 3) Create statement to link file to parent object
-     */
-    uploadFileDirect(input: {
-        file: File | Blob;
-        uuidToAttach: UUID;
-        label?: string;
-    }): Promise<ApiResponse<UUFileDTO | null>>;
     addPropertyToObject(objectUuid: UUID, property: Partial<UUPropertyDTO> & {
         key: string;
     }): Promise<ApiResponse<UUPropertyDTO>>;
@@ -125,10 +107,20 @@ export declare class NodeServiceClient {
      */
     getGroup(groupUUID: UUID, options?: RequestOptions): Promise<GroupCreateDTO>;
     /**
-     * List records in a group
+     * List records in a group (paginated)
      * GET /api/access/groups/{groupUUID}/records
      */
-    listGroupRecords(groupUUID: UUID, options?: RequestOptions): Promise<GroupRecord[]>;
+    listGroupRecords(groupUUID: UUID, params?: GroupListParams, options?: RequestOptions): Promise<PageImplGroupRecord>;
+    /**
+     * List groups owned by the authenticated user (non-default only, paginated)
+     * GET /api/access/groups/own
+     */
+    listOwnGroups(params?: GroupListParams, options?: RequestOptions): Promise<PageImplGroupFullDTO>;
+    /**
+     * List groups explicitly shared with the authenticated user (paginated)
+     * GET /api/access/groups/shared
+     */
+    listSharedGroups(params?: GroupListParams, options?: RequestOptions): Promise<PageImplGroupFullDTO>;
     /**
      * Add records to a group
      * POST /api/access/groups/{groupUUID}/records
@@ -140,10 +132,15 @@ export declare class NodeServiceClient {
      */
     createOrUpdateMathFormula(formula: UUMathFormulaDTO): Promise<UUMathFormulaDTO>;
     /**
-     * Search math formulas
-     * POST /api/UUMathFormula/find
+     * Search math formulas.
+     * POST /api/UUMathFormula/find — returns a Spring `Page<UUMathFormula>`
+     * envelope. Access `result.content` for the rows; pagination + audit
+     * fields live alongside.
      */
-    searchMathFormulas(body: UUMathFormulaFindDTO, options?: RequestOptions): Promise<UUMathFormulaDTO[]>;
+    searchMathFormulas(body: NodeFindDTO, params?: {
+        page?: number;
+        size?: number;
+    }, options?: RequestOptions): Promise<PageUUMathFormula>;
     /**
      * Soft delete a math formula
      * DELETE /api/UUMathFormula/{uuid}

package/dist/services/registry/registry-client.d.ts

@@ -15,19 +15,10 @@ export interface UUIDRecord {
 export interface UUIDCreationResponse {
     uuid: string;
 }
-export interface UUIDAuthParams {
-    uuid: string;
-    userUUID: string;
-    resourceId: string;
-}
 export declare class RegistryServiceClient {
     private axios;
     constructor(_config: ServiceConfig, _errorHandling: ErrorHandlingConfig, axios: AxiosInstance);
-    getOwnedUUIDs(): Promise<UUIDRecord[]>;
     createUUID(): Promise<UUIDCreationResponse>;
     getUUIDRecord(uuid: UUID): Promise<UUIDRecord>;
     updateUUIDRecordMeta(uuid: UUID, meta: Record<string, any>): Promise<UUIDRecord>;
-    authorizeUUIDRecord(params: UUIDAuthParams): Promise<{
-        success: boolean;
-    }>;
 }

package/dist/types/file-storage.d.ts

@@ -0,0 +1,198 @@
+/**
+ * File storage service DTOs.
+ *
+ * Shape sourced from `docs/filestorage.swagger.json`. Field names mirror the
+ * swagger exactly (`mimeType` not `contentType`, `fileReference` not
+ * `fileUuid`, `checksumSHA256` not `sha256` on `PartETag`).
+ *
+ * Flow after a successful upload:
+ *   1. `client.fileStorage.uploadFile(...)` → returns `FileStorageCompleteResponseDTO`
+ *      with `fileReference`.
+ *   2. Caller then registers the file with the node-network registry via
+ *      `client.node.createOrUpdateFile({ fileReference, fileName, contentType,
+ *      size, ... })` so the UUFile record can be attached to an object/property.
+ *
+ * The FileStorage service is bytes-only; node-network is records-and-relations.
+ */
+/**
+ * Request body for `POST /api/FileStorage/init`.
+ *
+ * `sha256` is hex-encoded (lowercase). All three required fields are
+ * server-validated; mismatches surface as 400 `InvalidRequest`.
+ */
+export interface FileStorageInitDTO {
+    fileName: string;
+    mimeType: string;
+    /** Bytes; min 1. int64 server-side. */
+    size: number;
+    /** Hex-encoded full-file SHA-256, lowercase. */
+    sha256: string;
+}
+/**
+ * Response from `POST /api/FileStorage/init` and `POST /{uploadId}/refresh`.
+ *
+ * Note: `urls.length === 1` and `partSize === null` together signal the
+ * single-shot path. Otherwise this is a multipart upload and the caller
+ * PUTs `file.slice((i-1)*partSize, i*partSize)` to `urls[i-1]`.
+ *
+ * `expiresAt` applies to every URL in `urls` — there is no per-URL expiry.
+ */
+export interface FileStorageInitResponseDTO {
+    uploadId: string;
+    fileReference: string;
+    urls: string[];
+    /** Bytes per part; null for single-shot. */
+    partSize: number | null;
+    /** ISO-8601 timestamp — all URLs in `urls` expire at this moment. */
+    expiresAt: string;
+    /**
+     * When `true`, the presigned PUT URLs include `x-amz-checksum-sha256` in
+     * their `SignedHeaders` and the SDK must send a base64 per-part SHA-256
+     * with every PUT (S3 verifies on the spot). When `false`/missing, the
+     * SDK skips the header — a stray header on a `SignedHeaders=host` URL
+     * would 403 with `SignatureDoesNotMatch`.
+     */
+    checksumValidation?: boolean;
+}
+/**
+ * Request body for `POST /api/FileStorage/{uploadId}/refresh`.
+ *
+ * When `partNumbers` is omitted or empty, the server returns fresh URLs for
+ * every part in the original init batch. When provided, the response `urls`
+ * array contains URLs only for those part numbers, in the same order. Pass
+ * the missing parts only to keep refresh responses small for huge multipart
+ * uploads.
+ */
+export interface FileStorageRefreshDTO {
+    partNumbers?: number[];
+}
+/**
+ * A completed part with its server-returned ETag.
+ *
+ * `checksumSHA256` is optional. When the SDK computes per-part SHA-256 it
+ * sends the base64-encoded digest here so the server can pass it through to
+ * S3's per-part integrity check (`x-amz-checksum-sha256`).
+ */
+export interface PartETag {
+    partNumber: number;
+    etag: string;
+    /** Base64-encoded per-part SHA-256. Omit if not computed. */
+    checksumSHA256?: string;
+}
+/**
+ * Request body for `POST /api/FileStorage/{uploadId}/complete`.
+ *
+ * Single-shot uploads (where `urls.length === 1`) still send a one-element
+ * `parts` array with `partNumber: 1` and the ETag returned from the single
+ * PUT. The server uses the array length to dispatch single-shot vs multipart
+ * completion internally.
+ */
+export interface FileStorageCompleteDTO {
+    parts: PartETag[];
+}
+/** Lifecycle states surfaced via `status` on metadata + complete responses. */
+export type FileStatus = 'PENDING' | 'UPLOADING' | 'READY' | 'FAILED' | 'DELETED';
+/**
+ * Response from `POST /api/FileStorage/{uploadId}/complete`.
+ *
+ * `status` is normally `READY`. If size/SHA-256 verification fails the
+ * server returns `FAILED` and the bytes are reclaimed.
+ */
+export interface FileStorageCompleteResponseDTO {
+    fileReference: string;
+    fileName: string;
+    mimeType: string;
+    size: number;
+    status: FileStatus;
+}
+import type { AuditUser } from './aggregates';
+/**
+ * Response from `GET /api/FileStorage/{fileReference}`.
+ *
+ * Carries the `mimeType` that was previously on `PreviewUrlResponseDTO`.
+ * Fetch this alongside `getPreviewUrl` when the consumer needs to pick the
+ * right preview element (image vs PDF vs video).
+ */
+export interface FileMetadataResponseDTO {
+    fileReference: string;
+    fileName: string;
+    mimeType: string;
+    size: number;
+    /** Hex-encoded full-file SHA-256 (lowercase) — what the client sent at init. */
+    sha256: string;
+    status: FileStatus;
+    createdBy: AuditUser;
+    /** ISO-8601. */
+    createdAt: string;
+}
+/**
+ * Response from `GET /api/FileStorage/{fileReference}/preview-url`.
+ *
+ * The URL has `response-content-disposition=inline` baked in by the server
+ * for whitelisted MIME types; for everything else the server bakes in
+ * `attachment` to neutralize stored-XSS via MIME spoofing.
+ */
+export interface PreviewUrlResponseDTO {
+    url: string;
+    /** ISO-8601. */
+    expiresAt: string;
+}
+export type InitUploadRequest = FileStorageInitDTO;
+export type InitUploadResponse = FileStorageInitResponseDTO;
+export type RefreshUrlsRequest = FileStorageRefreshDTO;
+export type CompletedPart = PartETag;
+export type CompleteUploadRequest = FileStorageCompleteDTO;
+export type CompleteUploadResponse = FileStorageCompleteResponseDTO;
+export type FileMetadata = FileMetadataResponseDTO;
+export type PreviewUrlResponse = PreviewUrlResponseDTO;
+/**
+ * URL of `GET /api/FileStorage/{fileReference}/download` — unauthenticated
+ * endpoint that 302-redirects to a presigned S3 URL with
+ * `Content-Disposition: attachment` baked in. The SDK builds this synchronously;
+ * the browser navigates and S3 serves the download.
+ */
+export interface DownloadUrlResponse {
+    url: string;
+}
+/**
+ * Typed errors thrown by `FileStorageServiceClient`. Map RFC 7807 ProblemDetails
+ * from the backend + S3-side errors into one of these kinds.
+ *
+ * - `BadDigest` / `ChecksumMismatch` — content hash mismatch (S3 / backend).
+ * - `InvalidRequest` — 400-class validation failure.
+ * - `NotFound` — file or uploadId doesn't exist.
+ * - `Expired` — presigned URL expired (parse S3 XML `AccessDenied`).
+ * - `Forbidden` — terminal 403 (e.g. `SignatureDoesNotMatch`).
+ * - `Throttled` — 429; honor `retryAfter`.
+ * - `QuotaExceeded` — storage quota.
+ * - `CorsOrNetwork` — fetch threw TypeError ("Failed to fetch") — typically
+ *    a CORS misconfig on the bucket. Distinct from a real network failure
+ *    so we surface a useful message during deployment.
+ * - `Aborted` — `AbortSignal` fired.
+ */
+export type FileStorageErrorKind = 'BadDigest' | 'ChecksumMismatch' | 'InvalidRequest' | 'NotFound' | 'Expired' | 'Forbidden' | 'Throttled' | 'QuotaExceeded' | 'CorsOrNetwork' | 'Aborted';
+export declare class FileStorageError extends Error {
+    readonly kind: FileStorageErrorKind;
+    /** Seconds; populated for `Throttled` from the `Retry-After` header. */
+    readonly retryAfter?: number;
+    /** Underlying cause (axios error, fetch TypeError, S3 XML body, etc.) — debug only. */
+    readonly cause?: unknown;
+    constructor(kind: FileStorageErrorKind, message: string, options?: {
+        retryAfter?: number;
+        cause?: unknown;
+    });
+}
+/**
+ * Input to `FileStorageServiceClient.uploadFile()`.
+ *
+ * `concurrency` controls per-file part parallelism (default 6, cap 8). For
+ * the global file concurrency cap, see `FileUploadService` in the UI.
+ */
+export interface UploadFileInput {
+    file: File | Blob;
+    fileName?: string;
+    contentType?: string;
+    onProgress?: (loaded: number, total: number) => void;
+    signal?: AbortSignal;
+    concurrency?: number;
+}

package/dist/types/groups.d.ts

@@ -68,3 +68,31 @@ export interface GroupRecord {
     groupUUID?: string;
     recordUUID?: string;
 }
+export interface PageImplGroupRecord {
+    totalPages: number;
+    totalElements: number;
+    size: number;
+    content: GroupRecord[];
+    number: number;
+    numberOfElements: number;
+    first: boolean;
+    last: boolean;
+    empty: boolean;
+    pageable: {
+        paged: boolean;
+        pageNumber: number;
+        pageSize: number;
+        offset: number;
+        sort: {
+            sorted: boolean;
+            empty: boolean;
+            unsorted: boolean;
+        };
+        unpaged: boolean;
+    };
+    sort: {
+        sorted: boolean;
+        empty: boolean;
+        unsorted: boolean;
+    };
+}

package/dist/types/index.d.ts

@@ -9,3 +9,4 @@ export * from './aggregates';
 export * from './groups';
 export * from './math-formulas';
 export * from './user';
+export * from './file-storage';

package/dist/types/math-formulas.d.ts

@@ -1,10 +1,14 @@
 /**
- * Math Formula and Calculation types (from Swagger documentation)
+ * Math Formula and Calculation types.
+ *
+ * Shape sourced from `docs/node.swagger.json`. Write-side uses the lean
+ * `*DTO` shapes; read-side (find responses) returns the full entity with
+ * audit fields wrapped in a Spring `Page<T>` envelope.
  */
-import { UUID } from './services';
+import { NodeFindDTO, UUID } from './services';
+import type { AuditUser } from './aggregates';
 /**
- * UUMathFormula Data Transfer Object
- * Represents a reusable math formula definition
+ * UUMathFormulaDTO — request body for `POST /api/UUMathFormula`.
  */
 export interface UUMathFormulaDTO {
     uuid: UUID;
@@ -15,8 +19,8 @@ export interface UUMathFormulaDTO {
     version?: string;
 }
 /**
- * UUMathFormulaCalc Data Transfer Object
- * Represents a calculation instance that links a formula to property values
+ * UUMathFormulaCalcDTO — request body for `POST /api/UUMathFormulaCalc`.
+ * Links a formula to concrete property-value bindings + output target.
  */
 export interface UUMathFormulaCalcDTO {
     uuid: UUID;
@@ -24,47 +28,79 @@ export interface UUMathFormulaCalcDTO {
     args: UUMathFormulaCalcArg[];
     result: UUMathFormulaCalcResult;
 }
-/**
- * Argument for a formula calculation - maps a variable name to a property value
- */
+/** Maps a variable name in the expression to a property-value UUID. */
 export interface UUMathFormulaCalcArg {
     name: string;
     propertyValueUUID: UUID;
 }
-/**
- * Result of a formula calculation - references the output property value
- */
+/** References the property-value UUID that will receive the computed result. */
 export interface UUMathFormulaCalcResult {
     propertyValueUUID: UUID;
 }
 /**
- * Search parameters for finding math formulas
+ * UUMathFormula — entity shape returned by `POST /api/UUMathFormula/find`.
+ * Adds audit + soft-delete fields on top of the DTO shape.
  */
-export interface UUMathFormulaFindDTO {
-    uuid?: UUID;
+export interface UUMathFormula {
+    uuid: UUID;
     name?: string;
-    groupUUID?: UUID;
+    expression?: string;
+    description?: string;
+    version?: string;
+    createdAt?: string;
+    createdBy?: AuditUser;
+    lastUpdatedAt?: string;
+    lastUpdatedBy?: AuditUser;
+    softDeletedAt?: string;
+    softDeleteBy?: AuditUser;
     softDeleted?: boolean;
-    accessFind?: {
-        readDefaultGroup?: boolean;
-        readOwnGroups?: boolean;
-        readPublicGroups?: boolean;
-        readUserSharedGroups?: boolean;
-        groupUUIDList?: string[];
-    };
 }
 /**
- * Search parameters for finding formula calculations
+ * Request body for `POST /api/UUMathFormula/find`. Swagger requires only
+ * `{ nodeFind, page, size }` — past flattened fields (`uuid`, `name`, etc.)
+ * are no longer accepted at the top level.
+ */
+export interface UUMathFormulaFindDTO {
+    nodeFind?: NodeFindDTO;
+    /** Zero-based page index. */
+    page?: number;
+    /** Page size. */
+    size?: number;
+}
+/**
+ * UUMathFormulaCalc find still routes through the generic
+ * `NodeFindRequestDTO` (page response is `object` in swagger — kept loose
+ * here until the backend tightens the contract).
  */
 export interface UUMathFormulaCalcFindDTO {
-    uuid?: UUID;
-    groupUUID?: UUID;
-    softDeleted?: boolean;
-    accessFind?: {
-        readDefaultGroup?: boolean;
-        readOwnGroups?: boolean;
-        readPublicGroups?: boolean;
-        readUserSharedGroups?: boolean;
-        groupUUIDList?: string[];
-    };
+    nodeFind?: NodeFindDTO;
+    page?: number;
+    size?: number;
+}
+export interface SortObject {
+    sorted?: boolean;
+    unsorted?: boolean;
+    empty?: boolean;
+}
+export interface PageableObject {
+    paged?: boolean;
+    unpaged?: boolean;
+    pageNumber?: number;
+    pageSize?: number;
+    offset?: number;
+    sort?: SortObject;
+}
+/** Spring `Page<UUMathFormula>` envelope. */
+export interface PageUUMathFormula {
+    content?: UUMathFormula[];
+    totalElements?: number;
+    totalPages?: number;
+    number?: number;
+    size?: number;
+    numberOfElements?: number;
+    first?: boolean;
+    last?: boolean;
+    empty?: boolean;
+    pageable?: PageableObject;
+    sort?: SortObject;
 }

package/dist/types/services.d.ts

@@ -108,17 +108,16 @@ export interface UUFileDTO {
     label?: string;
     contentType?: string;
     size?: number;
-    fileContentBase64?: string;
 }
 export interface NodeFindDTO {
     uuid?: UUID;
     softDeleted?: boolean;
 }
-export interface UUFileFindRequestDTO {
+export interface NodeFindRequestDTO {
     nodeFind?: NodeFindDTO;
     accessFind?: AccessFindDTO;
-    includeFileContentBase64?: boolean;
 }
+export type UUFileFindRequestDTO = NodeFindRequestDTO;
 export interface UUAddressDTO {
     uuid: UUID;
     groupUUID?: UUID;

package/dist/utils/index.d.ts

@@ -2,4 +2,3 @@
  * Utility functions export
  */
 export * from './jwt-utils';
-export * from './base64';