@withstudiocms/sdk 0.0.0-beta.0 → 0.1.0

package/dist/modules/delete/index.d.ts

@@ -0,0 +1,141 @@
+import { Effect } from '@withstudiocms/effect';
+import CacheService from '../../cache.js';
+import { DBClientLive, SDKDefaults } from '../../context.js';
+/**
+ * SDKDeleteModule
+ *
+ * Effect generator that builds and returns the Delete API for the StudioCMS SDK.
+ *
+ * This module wires together low-level database delete operations, input validation
+ * (via encoders), cache clearing and higher-level helpers to provide a cohesive
+ * deletion surface for pages, page content, tags, categories, permissions, diff
+ * tracking, folders and users.
+ *
+ * Remarks
+ * - All low-level DB deletes are wrapped with a validation encoder (withEncoder)
+ *   and execute the underlying query using executeTakeFirstOrThrow; absent rows
+ *   will surface as errors which are handled by the module's error pipeline.
+ * - High-level helpers compose these low-level operations into meaningful flows:
+ *   - Page deletion clears diff tracking, page content and page data, then clears relevant caches.
+ *   - Folder deletion triggers subsequent updates to folder list and folder tree views.
+ *   - User deletion clears user references and prevents deletion of the platform
+ *     "ghost" (internal) user.
+ * - The module uses a shared error handler (_handleErrors) to normalize errors into
+ *   DeletionResponse values where possible.
+ *
+ * Error handling
+ * - DB-level errors (not found / constraint failures) thrown by executeTakeFirstOrThrow
+ *   are propagated into the module's error-handling pipeline and converted into
+ *   DeletionResponse values by _handleErrors.
+ * - Ghost user protection surfaces a GhostUserError that is caught and turned into
+ *   an appropriate DeletionResponse explaining that the internal user cannot be deleted.
+ * - Folder update failures are specially caught and returned with an explanatory message.
+ *
+ * Side effects
+ * - Cache/derived-data clearing routines are invoked where appropriate (e.g. page cache
+ *   clearing after deleting page content).
+ * - Folder deletion triggers background updates to folder list and folder tree.
+ *
+ * Returns
+ * - An Effect that, when executed, yields an object containing the DELETE API
+ *   described above. Each method itself is an Effect producing a DeletionResponse
+ *   describing success or a mapped error.
+ *
+ * Example
+ * - const deleteModule = yield* SDKDeleteModule;
+ * - yield* deleteModule.page('page-id-123') // returns a DeletionResponse effect
+ */
+export declare const SDKDeleteModule: Effect.Effect<{
+    /**
+     * Deletes a page by its ID.
+     *
+     * @param id - The ID of the page to delete.
+     * @returns An effect that resolves to a success or error message.
+     */
+    page: (id: string) => Effect.Effect<{
+        status: "success" | "error";
+        message: string;
+    }, never, never>;
+    /**
+     * Deletes page content by its ID.
+     *
+     * @param id - The ID of the page content to delete.
+     * @returns An effect that resolves to a success or error message.
+     */
+    pageContent: (id: string) => Effect.Effect<{
+        status: "success" | "error";
+        message: string;
+    }, never, never>;
+    /**
+     * Deletes page content for a specific language by its ID and language.
+     *
+     * @param id - The ID of the page content to delete.
+     * @param lang - The language of the page content to delete.
+     * @returns An effect that resolves to a success or error message.
+     */
+    pageContentLang: (id: string, lang: string) => Effect.Effect<{
+        status: "success" | "error";
+        message: string;
+    }, never, never>;
+    /**
+     * Deletes a tag by its ID.
+     *
+     * @param id - The ID of the tag to delete.
+     * @returns An effect that resolves to a success or error message.
+     */
+    tags: (id: number) => Effect.Effect<{
+        status: "success" | "error";
+        message: string;
+    }, never, never>;
+    /**
+     * Deletes a category by its ID.
+     *
+     * @param id - The ID of the category to delete.
+     * @returns An effect that resolves to a success or error message.
+     */
+    categories: (id: number) => Effect.Effect<{
+        status: "success" | "error";
+        message: string;
+    }, never, never>;
+    /**
+     * Deletes permissions for a specific user by their ID.
+     *
+     * @param userId - The ID of the user whose permissions to delete.
+     * @returns An effect that resolves to a success or error message.
+     */
+    permissions: (userId: string) => Effect.Effect<{
+        status: "success" | "error";
+        message: string;
+    }, never, never>;
+    /**
+     * Deletes diff tracking entry by diff ID.
+     *
+     * @param id - The ID of the diff tracking entry to be deleted.
+     * @returns An effect that represents the deletion operation.
+     */
+    diffTracking: (id: string) => Effect.Effect<{
+        status: "success" | "error";
+        message: string;
+    }, never, never>;
+    /**
+     * Deletes a folder by its ID.
+     *
+     * @param folderId - The ID of the folder to delete.
+     * @returns An effect that resolves to a success or error message.
+     */
+    folder: (folderId: string) => Effect.Effect<{
+        status: "success" | "error";
+        message: string;
+    }, never, never>;
+    /**
+     * Deletes a user by their ID.
+     *
+     * @param userId - The ID of the user to delete.
+     * @returns An effect that resolves to a success or error message.
+     */
+    user: (userId: string) => Effect.Effect<{
+        status: "success" | "error";
+        message: string;
+    }, never, never>;
+}, never, DBClientLive | SDKDefaults | import("../../context.js").StorageManagerResolver | CacheService | import("@withstudiocms/effect").Deepmerge>;
+export default SDKDeleteModule;

package/dist/modules/delete/index.js

@@ -0,0 +1,279 @@
+import { Effect, Schema } from "@withstudiocms/effect";
+import CacheService from "../../cache.js";
+import { cacheTags } from "../../consts.js";
+import { DBClientLive, SDKDefaults } from "../../context.js";
+import SDKClearModule from "../clear/index.js";
+import SDKUpdateModule from "../update/index.js";
+import { SDKUsers } from "../util/users.js";
+class GhostUserError {
+  _tag = "GhostUserError";
+}
+const _handleErrors = Effect.catchTags({
+  DBCallbackFailure: (cause) => Effect.succeed({
+    status: "error",
+    message: cause.message
+  }),
+  NotFoundError: () => Effect.succeed({
+    status: "error",
+    message: "database entry not found"
+  }),
+  QueryError: (cause) => Effect.succeed({
+    status: "error",
+    message: cause.message
+  }),
+  QueryParseError: (cause) => Effect.succeed({
+    status: "error",
+    message: cause.message
+  })
+});
+const SDKDeleteModule = Effect.gen(function* () {
+  const [{ withEncoder }, clear, users, update, { GhostUserDefaults }, { invalidateTags }] = yield* Effect.all([
+    DBClientLive,
+    SDKClearModule,
+    SDKUsers,
+    SDKUpdateModule,
+    SDKDefaults,
+    CacheService
+  ]);
+  const _deleteDiffTrackingByPageId = withEncoder({
+    encoder: Schema.String,
+    callbackFn: (db, pageId) => db(
+      (client) => client.deleteFrom("StudioCMSDiffTracking").where("pageId", "=", pageId).executeTakeFirstOrThrow()
+    )
+  });
+  const _deleteDiffTrackingByDiffId = withEncoder({
+    encoder: Schema.String,
+    callbackFn: (db, diffId) => db(
+      (client) => client.deleteFrom("StudioCMSDiffTracking").where("id", "=", diffId).executeTakeFirstOrThrow()
+    )
+  });
+  const _deletePageContentByPageId = withEncoder({
+    encoder: Schema.String,
+    callbackFn: (db, pageId) => db(
+      (client) => client.deleteFrom("StudioCMSPageContent").where("contentId", "=", pageId).executeTakeFirstOrThrow()
+    )
+  });
+  const _deletePageDataById = withEncoder({
+    encoder: Schema.String,
+    callbackFn: (db, pageId) => db(
+      (client) => client.deleteFrom("StudioCMSPageData").where("id", "=", pageId).executeTakeFirstOrThrow()
+    )
+  });
+  const _deletePageContentLangByIdAndLang = withEncoder({
+    encoder: Schema.Struct({
+      id: Schema.String,
+      lang: Schema.String
+    }),
+    callbackFn: (db, { id, lang }) => db(
+      (client) => client.deleteFrom("StudioCMSPageContent").where((eb) => eb.and([eb("contentId", "=", id), eb("contentLang", "=", lang)])).executeTakeFirstOrThrow()
+    )
+  });
+  const _deleteTagsById = withEncoder({
+    encoder: Schema.Number,
+    callbackFn: (db, id) => db(
+      (client) => client.deleteFrom("StudioCMSPageDataTags").where("id", "=", id).executeTakeFirstOrThrow()
+    )
+  });
+  const _deleteCategoriesById = withEncoder({
+    encoder: Schema.Number,
+    callbackFn: (db, id) => db(
+      (client) => client.deleteFrom("StudioCMSPageDataCategories").where("id", "=", id).executeTakeFirstOrThrow()
+    )
+  });
+  const _deletePermissionDataByUserId = withEncoder({
+    encoder: Schema.String,
+    callbackFn: (db, userId) => db(
+      (client) => client.deleteFrom("StudioCMSPermissions").where("user", "=", userId).executeTakeFirstOrThrow()
+    )
+  });
+  const _deleteFolderById = withEncoder({
+    encoder: Schema.String,
+    callbackFn: (db, folderId) => db(
+      (client) => client.deleteFrom("StudioCMSPageFolderStructure").where("id", "=", folderId).executeTakeFirstOrThrow()
+    )
+  });
+  const _deleteUserById = withEncoder({
+    encoder: Schema.String,
+    callbackFn: (db, userId) => db(
+      (client) => client.deleteFrom("StudioCMSUsersTable").where("id", "=", userId).executeTakeFirstOrThrow()
+    )
+  });
+  const _deletePageById = Effect.fn(
+    (id) => _deleteDiffTrackingByPageId(id).pipe(
+      Effect.flatMap(() => _deletePageContentByPageId(id)),
+      Effect.flatMap(() => _deletePageDataById(id)),
+      Effect.flatMap(() => clear.page.byId(id)),
+      Effect.map(() => ({
+        status: "success",
+        message: `Page with ID ${id} has been deleted successfully`
+      })),
+      _handleErrors
+    )
+  );
+  const _deletePageContent = Effect.fn(
+    (id) => _deletePageContentByPageId(id).pipe(
+      Effect.flatMap(() => clear.page.byId(id)),
+      Effect.map(() => ({
+        status: "success",
+        message: `Page content with ID ${id} has been deleted successfully`
+      })),
+      _handleErrors
+    )
+  );
+  const _deletePageContentLang = Effect.fn(
+    (id, lang) => _deletePageContentLangByIdAndLang({ id, lang }).pipe(
+      Effect.flatMap(() => clear.page.byId(id)),
+      Effect.map(() => ({
+        status: "success",
+        message: `Page content with ID ${id} and language ${lang} has been deleted successfully`
+      })),
+      _handleErrors
+    )
+  );
+  const _deletePageTag = Effect.fn(
+    (id) => _deleteTagsById(id).pipe(
+      Effect.tap(() => invalidateTags(cacheTags.tags)),
+      Effect.map(() => ({
+        status: "success",
+        message: `Tag with ID ${id} has been deleted successfully`
+      })),
+      _handleErrors
+    )
+  );
+  const _deletePageCategory = Effect.fn(
+    (id) => _deleteCategoriesById(id).pipe(
+      Effect.tap(() => invalidateTags(cacheTags.categories)),
+      Effect.map(() => ({
+        status: "success",
+        message: `Category with ID ${id} has been deleted successfully`
+      })),
+      _handleErrors
+    )
+  );
+  const _deletePermission = Effect.fn(
+    (userId) => _deletePermissionDataByUserId(userId).pipe(
+      Effect.map(() => ({
+        status: "success",
+        message: `Permissions for user with ID ${userId} have been deleted successfully`
+      })),
+      _handleErrors
+    )
+  );
+  const _deleteDiffTracking = Effect.fn(
+    (id) => _deleteDiffTrackingByDiffId(id).pipe(
+      Effect.map(() => ({
+        status: "success",
+        message: `Diff tracking entry with ID ${id} has been deleted successfully`
+      })),
+      _handleErrors
+    )
+  );
+  const _deleteFolder = Effect.fn(
+    (folderId) => _deleteFolderById(folderId).pipe(
+      Effect.tap(() => Effect.all([update.folderList, update.folderTree])),
+      Effect.map(() => ({
+        status: "success",
+        message: `Folder with ID ${folderId} has been deleted successfully`
+      })),
+      Effect.catchTag(
+        "FolderTreeError",
+        (cause) => Effect.succeed({
+          status: "error",
+          message: `Failed to update folder tree after deleting folder with ID ${folderId}: ${cause.message}`
+        })
+      ),
+      _handleErrors
+    )
+  );
+  const _isNotGhostUser = (userId) => userId !== GhostUserDefaults.id ? Effect.fail(new GhostUserError()) : Effect.succeed(false);
+  const _deleteUser = Effect.fn(
+    (userId) => _isNotGhostUser(userId).pipe(
+      Effect.flatMap(() => users.clearUserReferences(userId)),
+      Effect.flatMap(() => _deleteUserById(userId)),
+      Effect.map(() => ({
+        status: "success",
+        message: `User with ID ${userId} has been deleted successfully`
+      })),
+      Effect.catchTag(
+        "GhostUserError",
+        () => Effect.succeed({
+          status: "error",
+          message: `User with ID ${userId} is an internal user and cannot be deleted.`
+        })
+      ),
+      _handleErrors
+    )
+  );
+  const DELETE = {
+    /**
+     * Deletes a page by its ID.
+     *
+     * @param id - The ID of the page to delete.
+     * @returns An effect that resolves to a success or error message.
+     */
+    page: _deletePageById,
+    /**
+     * Deletes page content by its ID.
+     *
+     * @param id - The ID of the page content to delete.
+     * @returns An effect that resolves to a success or error message.
+     */
+    pageContent: _deletePageContent,
+    /**
+     * Deletes page content for a specific language by its ID and language.
+     *
+     * @param id - The ID of the page content to delete.
+     * @param lang - The language of the page content to delete.
+     * @returns An effect that resolves to a success or error message.
+     */
+    pageContentLang: _deletePageContentLang,
+    /**
+     * Deletes a tag by its ID.
+     *
+     * @param id - The ID of the tag to delete.
+     * @returns An effect that resolves to a success or error message.
+     */
+    tags: _deletePageTag,
+    /**
+     * Deletes a category by its ID.
+     *
+     * @param id - The ID of the category to delete.
+     * @returns An effect that resolves to a success or error message.
+     */
+    categories: _deletePageCategory,
+    /**
+     * Deletes permissions for a specific user by their ID.
+     *
+     * @param userId - The ID of the user whose permissions to delete.
+     * @returns An effect that resolves to a success or error message.
+     */
+    permissions: _deletePermission,
+    /**
+     * Deletes diff tracking entry by diff ID.
+     *
+     * @param id - The ID of the diff tracking entry to be deleted.
+     * @returns An effect that represents the deletion operation.
+     */
+    diffTracking: _deleteDiffTracking,
+    /**
+     * Deletes a folder by its ID.
+     *
+     * @param folderId - The ID of the folder to delete.
+     * @returns An effect that resolves to a success or error message.
+     */
+    folder: _deleteFolder,
+    /**
+     * Deletes a user by their ID.
+     *
+     * @param userId - The ID of the user to delete.
+     * @returns An effect that resolves to a success or error message.
+     */
+    user: _deleteUser
+  };
+  return DELETE;
+});
+var delete_default = SDKDeleteModule;
+export {
+  SDKDeleteModule,
+  delete_default as default
+};

package/dist/modules/diffTracking/index.d.ts

@@ -0,0 +1,188 @@
+import { Effect } from '@withstudiocms/effect';
+import { DBClientLive } from '../../context.js';
+import type { diffReturn, tsPageDataSelect } from '../../types.js';
+declare const DiffTrackingError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "DiffTrackingError";
+} & Readonly<A>;
+/**
+ * DiffTrackingError
+ *
+ * Represents an error specific to the Diff Tracking module.
+ *
+ * This error extends from `Data.TaggedError` with the tag `'DiffTrackingError'`
+ * and includes a `message` property to provide additional context about the issue.
+ *
+ * @example
+ * ```typescript
+ * throw new DiffTrackingError({ message: 'Diff entry not found' });
+ * ```
+ *
+ * @property message - A descriptive message providing context about the error.
+ */
+export declare class DiffTrackingError extends DiffTrackingError_base<{
+    message: string;
+}> {
+}
+/**
+ * SDKDiffTrackingModule
+ *
+ * Effect-based module that provides diff-tracking persistence and utilities for StudioCMS pages.
+ *
+ * Overview
+ * - Exposes a diffTracking API for creating, querying, reverting and clearing page diffs.
+ * - Built on top of an Effect runtime and a database client layer with schema codecs/encoders.
+ * - Uses unified diffs (created via createTwoFilesPatch), persists them to the StudioCMSDiffTracking table,
+ *   and post-processes records with a `fixDiff` parser to attach parsed metadata/structures.
+ *
+ * Public API (returned object)
+ * - insert(userId, pageId, data, diffLength): Effect
+ *   Creates a unified diff between data.content.start and data.content.end, persists a new diff record,
+ *   enforces a maximum number of diffs per page (diffLength) by removing oldest entries, and returns
+ *   the stored diff record after parsing (via fixDiff).
+ *
+ * - clear(pageId): Effect
+ *   Deletes all diff tracking records for the provided pageId.
+ *
+ * - get
+ *   - byPageId.all(pageId): Effect
+ *     Returns all diffs for the page (ordered by timestamp ascending) with parsed metadata.
+ *   - byPageId.latest(pageId, count): Effect
+ *     Returns the latest `count` diffs for the page (after parsing).
+ *   - byUserId.all(userId): Effect
+ *     Returns all diffs authored by the user with parsed metadata.
+ *   - byUserId.latest(userId, count): Effect
+ *     Returns the latest `count` diffs authored by the user.
+ *   - single(diffId): Effect
+ *     Returns a single diff by id with parsed metadata, or undefined if not found.
+ *
+ * - revertToDiff(id, type): Effect
+ *   Reverts a page to the state represented by the diff with the given id. `type` controls what is reverted:
+ *   'content' | 'data' | 'both'.
+ *   Behavior:
+ *     - Validates that the diff entry exists; fails with DiffTrackingError if not found.
+ *     - When reverting data, decodes/encodes page metadata with configured schemas and updates StudioCMSPageData.
+ *       If required IDs are missing in metadata, fails with DiffTrackingError.
+ *     - When reverting content, writes the saved pageContentStart back to StudioCMSPageContent.
+ *     - Deletes all diffs that were created after the reverted diff to preserve a linear history.
+ *     - Returns the reverted diff entry after parsing.
+ *
+ * - utils
+ *   - getMetaDataDifferences(obj1, obj2): Effect
+ *     Compares two metadata objects and returns an array of differences:
+ *     { label: string, previous: unknown, current: unknown }.
+ *     Ignores a small set of blacklisted fields (publishedAt, updatedAt, authorId, contributorIds),
+ *     maps known metadata keys to friendly labels, and performs array-aware comparison to avoid
+ *     spurious diffs for deeply-equal arrays.
+ *   - getDiffHTML(diff: string): string
+ *     Converts a unified diff string into an HTML representation for display.
+ *
+ * Implementation notes
+ * - Database interactions use withCodec/withEncoder wrappers to validate/encode inputs and decode outputs.
+ * - insert generates a new UUID for the diff id using crypto.randomUUID().
+ * - Query ordering for lists is ascending by timestamp; "latest" helpers slice results accordingly.
+ * - All public functions return Effect-based values; callers must run/interpret these via the project's Effect runtime.
+ *
+ * Error handling
+ * - Domain errors (e.g. missing diff entry or invalid metadata for revert) are signaled with DiffTrackingError.
+ * - Database errors and codec/schema errors are propagated as failures of the returned Effects.
+ *
+ * Concurrency and retention
+ * - insert enforces retention by deleting the oldest diffs when the per-page count would exceed diffLength.
+ * - revertToDiff prunes any diffs that occurred after the reverted entry to maintain a consistent history.
+ */
+export declare const SDKDiffTrackingModule: Effect.Effect<{
+    /**
+     * Inserts a new diff tracking record into the database.
+     *
+     * @param userId - The ID of the user making the change.
+     * @param pageId - The ID of the page being changed.
+     * @param data - An object containing the start and end content and metadata.
+     * @param diffLength - The maximum number of diffs to retain for the page.
+     * @returns The inserted diff tracking record with parsed metadata.
+     */
+    insert: (userId: string, pageId: string, data: {
+        content: {
+            start: string;
+            end: string;
+        };
+        metaData: {
+            start: Partial<tsPageDataSelect>;
+            end: Partial<tsPageDataSelect>;
+        };
+    }, diffLength: number) => Effect.Effect<diffReturn, import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError | import("../util/parsers.js").ParsersError | import("../../lib/diff.js").DiffError, never>;
+    /**
+     * Clears all diff tracking records for a given page ID.
+     *
+     * @param pageId - The ID of the page to clear diff tracking records for.
+     * @returns The number of rows affected by the delete operation.
+     */
+    clear: (input: string) => Effect.Effect<import("kysely").DeleteResult[], import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, never>;
+    /**
+     * Utility functions for retrieving diff tracking records.
+     */
+    get: {
+        /**
+         * Retrieves all diff tracking records for a given page ID.
+         */
+        byPageId: {
+            /**
+             * Retrieves all diff tracking records for a given page ID.
+             */
+            all: (pageId: string) => Effect.Effect<diffReturn[], import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError | import("../util/parsers.js").ParsersError, never>;
+            /**
+             * Retrieves the latest `count` diff tracking records for a given page ID.
+             */
+            latest: (pageId: string, count: number) => Effect.Effect<diffReturn[], import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError | import("../util/parsers.js").ParsersError, never>;
+        };
+        /**
+         * Retrieves all diff tracking records for a given user ID.
+         */
+        byUserId: {
+            /**
+             * Retrieves all diff tracking records for a given user ID.
+             */
+            all: (userId: string) => Effect.Effect<diffReturn[], import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError | import("../util/parsers.js").ParsersError, never>;
+            /**
+             * Retrieves the latest `count` diff tracking records for a given user ID.
+             */
+            latest: (userId: string, count: number) => Effect.Effect<diffReturn[], import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError | import("../util/parsers.js").ParsersError, never>;
+        };
+        /**
+         * Retrieves a single diff tracking record by its ID.
+         */
+        single: (diffId: string) => Effect.Effect<diffReturn | undefined, import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError | import("../util/parsers.js").ParsersError, never>;
+    };
+    /**
+     * Reverts the page data and/or content to the state represented by the specified diff ID.
+     *
+     * @param id - The ID of the diff tracking record to revert to.
+     * @param type - The type of revert operation: 'content', 'data', or 'both'.
+     * @returns The reverted diff tracking record with parsed metadata.
+     */
+    revertToDiff: (id: string, type: "content" | "data" | "both") => Effect.Effect<diffReturn, import("effect/ParseResult").ParseError | import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError | import("../util/parsers.js").ParsersError | DiffTrackingError, never>;
+    /**
+     * Utility functions for diff tracking.
+     */
+    utils: {
+        /**
+         * Compares two metadata objects and returns the differences.
+         *
+         * @param obj1 - The first metadata object to compare.
+         * @param obj2 - The second metadata object to compare.
+         * @returns An array of differences, each containing the label, previous value, and current value.
+         */
+        getMetaDataDifferences: <T extends Record<string, unknown>>(obj1: T, obj2: T) => Effect.Effect<{
+            label: string;
+            previous: unknown;
+            current: unknown;
+        }[], never, never>;
+        /**
+         * Generates the HTML representation of a unified diff string.
+         *
+         * @param diff - The unified diff string to convert to HTML.
+         * @returns The HTML representation of the diff.
+         */
+        getDiffHTML: (diff: string, options?: import("diff2html").Diff2HtmlConfig | undefined) => Effect.Effect<string, import("../../lib/diff.js").DiffError, never>;
+    };
+}, never, DBClientLive>;
+export default SDKDiffTrackingModule;