@withstudiocms/sdk 0.0.0-beta.0 → 0.1.0

package/dist/modules/diffTracking/index.js

@@ -0,0 +1,277 @@
+import { Data, Effect, Schema } from "@withstudiocms/effect";
+import { DBClientLive } from "../../context.js";
+import { createTwoFilesPatch, diffHTML } from "../../lib/diff.js";
+import { StudioCMSDiffTracking, StudioCMSPageData } from "../../tables.js";
+import { SDKParsers } from "../util/parsers.js";
+class DiffTrackingError extends Data.TaggedError("DiffTrackingError") {
+}
+const SDKDiffTrackingModule = Effect.gen(function* () {
+  const [{ withCodec, withEncoder }, { fixDiff }] = yield* Effect.all([DBClientLive, SDKParsers]);
+  const _selectDiffByPageId = withCodec({
+    encoder: Schema.String,
+    decoder: Schema.Array(StudioCMSDiffTracking.Select),
+    callbackFn: (db, pageId) => db(
+      (client) => client.selectFrom("StudioCMSDiffTracking").selectAll().where("pageId", "=", pageId).orderBy("timestamp", "asc").execute()
+    )
+  });
+  const _selectDiffByUserId = withCodec({
+    encoder: Schema.String,
+    decoder: Schema.Array(StudioCMSDiffTracking.Select),
+    callbackFn: (db, userId) => db(
+      (client) => client.selectFrom("StudioCMSDiffTracking").selectAll().where("userId", "=", userId).orderBy("timestamp", "asc").execute()
+    )
+  });
+  const _selectDiffById = withCodec({
+    encoder: Schema.String,
+    decoder: Schema.UndefinedOr(StudioCMSDiffTracking.Select),
+    callbackFn: (db, diffId) => db(
+      (client) => client.selectFrom("StudioCMSDiffTracking").selectAll().where("id", "=", diffId).executeTakeFirst()
+    )
+  });
+  const _deleteDiffById = withEncoder({
+    encoder: Schema.String,
+    callbackFn: (db, diffId) => db((client) => client.deleteFrom("StudioCMSDiffTracking").where("id", "=", diffId).execute())
+  });
+  const _insertNewDiff = withCodec({
+    encoder: StudioCMSDiffTracking.Insert,
+    decoder: StudioCMSDiffTracking.Select,
+    callbackFn: (db, diff) => db(
+      (client) => client.transaction().execute(async (trx) => {
+        await trx.insertInto("StudioCMSDiffTracking").values(diff).executeTakeFirstOrThrow();
+        return await trx.selectFrom("StudioCMSDiffTracking").selectAll().where("id", "=", diff.id).executeTakeFirstOrThrow();
+      })
+    )
+  });
+  const clearPageDiffs = withEncoder({
+    encoder: Schema.String,
+    callbackFn: (db, pageId) => db(
+      (client) => client.deleteFrom("StudioCMSDiffTracking").where("pageId", "=", pageId).execute()
+    )
+  });
+  const _setPageData = withEncoder({
+    encoder: StudioCMSPageData.Update,
+    callbackFn: (db, data) => db(
+      (client) => client.updateTable("StudioCMSPageData").set(data).where("id", "=", data.id).execute()
+    )
+  });
+  const _setPageContent = withEncoder({
+    encoder: Schema.Struct({
+      contentId: Schema.String,
+      content: Schema.String
+    }),
+    callbackFn: (db, data) => db(
+      (client) => client.updateTable("StudioCMSPageContent").set({ content: data.content }).where("contentId", "=", data.contentId).execute()
+    )
+  });
+  const _checkDiffsLengthAndRemoveOldestIfTooLong = Effect.fn(function* (pageId, maxDiffs) {
+    const diffs = yield* _selectDiffByPageId(pageId);
+    if (diffs.length > maxDiffs) {
+      const diffsToDelete = diffs.length - maxDiffs;
+      for (let i = 0; i < diffsToDelete; i++) {
+        const oldestDiff = diffs[i];
+        yield* _deleteDiffById(oldestDiff.id);
+      }
+    }
+  });
+  const _insert = Effect.fn(
+    (userId, pageId, data, diffLength) => createTwoFilesPatch(
+      (patch) => patch("Content", "Content", data.content.start, data.content.end)
+    ).pipe(
+      Effect.tap(() => _checkDiffsLengthAndRemoveOldestIfTooLong(pageId, diffLength)),
+      Effect.flatMap(
+        (diff) => _insertNewDiff({
+          id: crypto.randomUUID(),
+          pageId,
+          userId,
+          diff,
+          pageContentStart: data.content.start,
+          pageMetaData: JSON.stringify(data.metaData),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      ),
+      Effect.flatMap((insertedDiff) => fixDiff(insertedDiff))
+    )
+  );
+  const _getByPageIdAll = Effect.fn(
+    (pageId) => _selectDiffByPageId(pageId).pipe(Effect.flatMap((diffs) => fixDiff(diffs)))
+  );
+  const _getByPageIdLatest = Effect.fn(
+    (pageId, count) => _getByPageIdAll(pageId).pipe(Effect.map((diffs) => diffs.slice(0, count)))
+  );
+  const _getByUserIdAll = Effect.fn(
+    (userId) => _selectDiffByUserId(userId).pipe(Effect.flatMap((diffs) => fixDiff(diffs)))
+  );
+  const _getByUserIdLatest = Effect.fn(
+    (userId, count) => _getByUserIdAll(userId).pipe(Effect.map((diffs) => diffs.slice(0, count)))
+  );
+  const _getSingleDiffById = Effect.fn(
+    (diffId) => _selectDiffById(diffId).pipe(
+      Effect.flatMap(
+        (diffOrNull) => diffOrNull ? fixDiff(diffOrNull) : Effect.succeed(void 0)
+      )
+    )
+  );
+  const _revertToDiff = Effect.fn(function* (id, type) {
+    const diffEntry = yield* _selectDiffById(id);
+    if (!diffEntry) {
+      return yield* new DiffTrackingError({ message: "Diff entry not found" });
+    }
+    const shouldRevertData = type === "data" || type === "both";
+    const shouldRevertContent = type === "content" || type === "both";
+    if (shouldRevertData) {
+      const pageData = diffEntry.pageMetaData;
+      if (!pageData.end.id || !pageData.start.id) {
+        return yield* new DiffTrackingError({ message: "Invalid page metadata for revert" });
+      }
+      yield* Schema.encode(StudioCMSPageData.Select)(pageData.start).pipe(
+        Effect.flatMap(Schema.decode(StudioCMSPageData.Update)),
+        Effect.flatMap(_setPageData)
+      );
+    }
+    if (shouldRevertContent) {
+      yield* _setPageContent({
+        content: diffEntry.pageContentStart,
+        contentId: diffEntry.pageId
+      });
+    }
+    const allDiffs = yield* _selectDiffByPageId(diffEntry.pageId);
+    const diffIndex = allDiffs.findIndex((d) => d.id === id);
+    for (let i = diffIndex + 1; i < allDiffs.length; i++) {
+      const diffToDelete = allDiffs[i];
+      yield* _deleteDiffById(diffToDelete.id);
+    }
+    return yield* fixDiff(diffEntry);
+  });
+  const _getMetaDataDifferences = Effect.fn(function* (obj1, obj2) {
+    const differences = [];
+    const Labels = {
+      package: "Page Type",
+      title: "Page Title",
+      description: "Page Description",
+      showOnNav: "Show in Navigation",
+      slug: "Page Slug",
+      contentLang: "Content Language",
+      heroImage: "Hero/OG Image",
+      categories: "Page Categories",
+      tags: "Page Tags",
+      showAuthor: "Show Author",
+      showContributors: "Show Contributors",
+      parentFolder: "Parent Folder",
+      draft: "Draft"
+    };
+    const processLabel = (label) => Effect.sync(() => Labels[label] ? Labels[label] : label);
+    for (const label in obj1) {
+      const blackListedLabels = [
+        "publishedAt",
+        "updatedAt",
+        "authorId",
+        "contributorIds"
+      ];
+      if (blackListedLabels.includes(label)) continue;
+      if (Object.hasOwn(obj1, label) && Object.hasOwn(obj2, label)) {
+        if (obj1[label] !== obj2[label]) {
+          if (Array.isArray(obj1[label]) && Array.isArray(obj2[label])) {
+            const arr1 = obj1[label];
+            const arr2 = obj2[label];
+            if (arr1.length === arr2.length && arr1.every((val, index) => val === arr2[index]))
+              continue;
+          }
+          differences.push({
+            label: yield* processLabel(label),
+            previous: obj1[label],
+            current: obj2[label]
+          });
+        }
+      }
+    }
+    return differences;
+  });
+  return {
+    /**
+     * 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: _insert,
+    /**
+     * 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: clearPageDiffs,
+    /**
+     * 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: _getByPageIdAll,
+        /**
+         * Retrieves the latest `count` diff tracking records for a given page ID.
+         */
+        latest: _getByPageIdLatest
+      },
+      /**
+       * Retrieves all diff tracking records for a given user ID.
+       */
+      byUserId: {
+        /**
+         * Retrieves all diff tracking records for a given user ID.
+         */
+        all: _getByUserIdAll,
+        /**
+         * Retrieves the latest `count` diff tracking records for a given user ID.
+         */
+        latest: _getByUserIdLatest
+      },
+      /**
+       * Retrieves a single diff tracking record by its ID.
+       */
+      single: _getSingleDiffById
+    },
+    /**
+     * 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: _revertToDiff,
+    /**
+     * 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: _getMetaDataDifferences,
+      /**
+       * 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: diffHTML
+    }
+  };
+});
+var diffTracking_default = SDKDiffTrackingModule;
+export {
+  DiffTrackingError,
+  SDKDiffTrackingModule,
+  diffTracking_default as default
+};

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

@@ -0,0 +1,372 @@
+import { Effect, type ParseResult } from '@withstudiocms/effect';
+import type { DBCallbackFailure } from '@withstudiocms/kysely/client';
+import type { DatabaseError } from '@withstudiocms/kysely/core/errors';
+import CacheService from '../../cache.js';
+import { DBClientLive, SDKDefaults } from '../../context.js';
+import type { CombinedPageData, MetaOnlyPageData, SingleRank } from '../../types.js';
+import { type CollectorError } from '../util/collectors.js';
+import { type FolderTreeError } from '../util/folderTree.js';
+import { type UsersError } from '../util/users.js';
+/**
+ * Input parameters for paginated queries.
+ *
+ * @property limit - The maximum number of items to return.
+ * @property offset - The number of items to skip before starting to collect the result set.
+ */
+export type PaginateInput = {
+    limit: number;
+    offset: number;
+};
+/**
+ * Error class for pagination-related issues.
+ */
+export declare class PaginateError extends Error {
+    readonly _tag = "PaginateError";
+}
+/**
+ * KillSwitch used to short-circuit Effect chains.
+ */
+export declare class KillSwitch {
+    readonly _tag = "KillSwitch";
+}
+/**
+ * SDKGetModule
+ *
+ * Effect generator that assembles and returns a read-only "GET" API for the StudioCMS SDK.
+ * The module wires together database access, collectors, folder-tree utilities, caching/memoization,
+ * schema decoding/encoding and other supporting services to produce a single object with
+ * convenient, type-safe Effect-based getters.
+ *
+ * Key characteristics
+ * - Returns an object `GET` containing grouped read operations (permissions, users, folders, pages, site config, etc.).
+ * - All operations return Effect-based results (Effect.Effect<...>) and are composed with validation, decoding and error handling.
+ * - Uses memoization with cache keys/tags for page-, folder- and tree-related queries to avoid redundant work.
+ * - Uses collectors to supplement raw DB rows with computed/aggregated "collected" data for pages and users.
+ * - Read-only: operations query database and services but do not mutate state.
+ *
+ * Main API surface (high level)
+ * - GET.permissionsLists
+ *   - all: returns combined ranks with their users.
+ *   - <rank>s: dynamically generated convenience functions for each rank (e.g. owners, admins, editors, visitors).
+ *
+ * - GET.users
+ *   - all(): returns all users (ghost user filtered out) with collected user data.
+ *   - byId(id): returns collected user data for a user id or undefined if not found.
+ *   - byUsername(username): returns collected user data for a username or undefined if not found.
+ *   - byEmail(email): returns collected user data for an email or undefined if not found.
+ *
+ * - GET.folder(folderId)
+ *   - Returns a memoized folder lookup by id (decoded).
+ *
+ * - GET.folderTree()
+ *   - Returns the folder structure built from folder definitions (memoized).
+ *
+ * - GET.folderList()
+ *   - Returns a list of available folders (memoized).
+ *
+ * - GET.siteConfig
+ *   - Proxy to SDK config getter for site configuration.
+ *
+ * - GET.latestVersion()
+ *   - Fetches the latest published version of StudioCMS from NPM.
+ *
+ * - GET.pages(includeDrafts?, metaOnly?, paginate?)
+ *   - Returns all pages (optionally paginated) and supports:
+ *     - includeDrafts: include drafts when true.
+ *     - metaOnly: when true returns meta-only representations (no defaultContent / multiLangContent).
+ *   - Validates pagination inputs (non-negative; default limit fallback).
+ *   - Uses memoized per-page collectors and returns either CombinedPageData[] or MetaOnlyPageData[].
+ *   - Errors are typed (e.g. DBCallbackFailure, FolderTreeError, DatabaseError, ParseResult.ParseError,
+ *     PaginateError, CollectorError) — all surfaced through Effects.
+ *
+ * - GET.page.byId(id, metaOnly?)
+ *   - Fetches a single page by id, collects full page data (or meta-only when requested).
+ *   - Returns the page data or `undefined` when not found.
+ *
+ * - GET.page.bySlug(slug, metaOnly?)
+ *   - Fetches a single page by slug, collects full page data (or meta-only when requested).
+ *   - Returns the page data or `undefined` when not found.
+ *
+ * - GET.packagePages(packageName, metaOnly?)
+ *   - Returns pages associated with a package. If none found, returns an empty array.
+ *
+ * - GET.folderPages(idOrName, includeDrafts?, metaOnly?, paginate?)
+ *   - Returns pages that belong to the given folder (identified by id or name).
+ *   - Supports same filtering, metaOnly and pagination semantics as GET.pages.
+ *
+ * - GET.pageFolderTree(excludeDrafts?)
+ *   - Returns a full folder tree structure enriched with pages placed into their folders.
+ *   - Built by merging folder definitions and page data, memoized for efficiency.
+ *   - Supports excluding draft pages when `excludeDrafts` is true.
+ *
+ * Implementation notes
+ * - Internal helpers:
+ *   - Schema-validated DB accessors (withCodec/withDecoder) provide typed DB reads.
+ *   - collectUserData / collectPageData transform raw DB rows into richer domain objects.
+ *   - memoize wraps potentially expensive collectors with cache keys and tags.
+ *   - validatePagination enforces sane paging and returns a PaginateError for invalid input.
+ *   - convertCombinedPageDataToMetaOnly strips content fields to produce meta-only return shapes.
+ *   - Some flows use a KillSwitch sentinel to convert "not found" database results into benign undefined/empty results.
+ *
+ * Errors
+ * - All functions return their results wrapped in Effect.Effect; errors from decoding, DB callbacks,
+ *   collectors, pagination validation, or folder-tree construction flow through the Effect error channel.
+ * - Page-related getters document a union of possible errors (DBCallbackFailure | FolderTreeError | DatabaseError |
+ *   ParseResult.ParseError | PaginateError | CollectorError).
+ *
+ * Example usage (conceptual)
+ * - GET.users.all()            -> Effect yielding collected user list
+ * - GET.page.byId("abc")       -> Effect yielding CombinedPageData | undefined
+ *
+ * Returns
+ * - An object (`GET`) with the described grouped read-only operations; each operation is an Effect-producing function.
+ */
+export declare const SDKGetModule: Effect.Effect<{
+    /**
+     * Lists of permissions categorized by user ranks.
+     */
+    permissionsLists: {
+        owners: () => Effect.Effect<SingleRank[], UsersError | DBCallbackFailure | DatabaseError, never>;
+        admins: () => Effect.Effect<SingleRank[], UsersError | DBCallbackFailure | DatabaseError, never>;
+        editors: () => Effect.Effect<SingleRank[], UsersError | DBCallbackFailure | DatabaseError, never>;
+        visitors: () => Effect.Effect<SingleRank[], UsersError | DBCallbackFailure | DatabaseError, never>;
+        /**
+         * Retrieves all combined ranks with their corresponding users.
+         *
+         * @returns An array of combined rank records.
+         */
+        all: () => Effect.Effect<import("../../types.js").CombinedRank[], DBCallbackFailure | DatabaseError | UsersError, never>;
+    };
+    /**
+     * User-related GET operations.
+     */
+    users: {
+        /**
+         * Retrieves all users excluding the ghost user.
+         *
+         * @returns An array of user data records.
+         */
+        all: () => Effect.Effect<import("../../types.js").CombinedUserData[], DBCallbackFailure | DatabaseError, never>;
+        /**
+         * Retrieves a user by their ID.
+         *
+         * @param userId - The ID of the user to fetch.
+         * @returns The user data record if found, otherwise undefined.
+         */
+        byId: (userId: string) => Effect.Effect<import("../../types.js").CombinedUserData | undefined, DBCallbackFailure | DatabaseError, never>;
+        /**
+         * Retrieves a user by their username.
+         *
+         * @param username - The username of the user to fetch.
+         * @returns The user data record if found, otherwise undefined.
+         */
+        byUsername: (username: string) => Effect.Effect<import("../../types.js").CombinedUserData | undefined, DBCallbackFailure | DatabaseError, never>;
+        /**
+         * Retrieves a user by their email.
+         *
+         * @param email - The email of the user to fetch.
+         * @returns The user data record if found, otherwise undefined.
+         */
+        byEmail: (email: string) => Effect.Effect<import("../../types.js").CombinedUserData | undefined, DBCallbackFailure | DatabaseError, never>;
+    };
+    /**
+     * Retrieves a folder by its ID.
+     *
+     * @param folderId - The ID of the folder to fetch.
+     * @returns The folder record if found, otherwise undefined.
+     */
+    folder: (folderId: string) => Effect.Effect<{
+        readonly id: string;
+        readonly name: string;
+        readonly parent?: string | null | undefined;
+    } | undefined, DBCallbackFailure | DatabaseError, never>;
+    /**
+     * Retrieves the folder tree structure.
+     *
+     * @returns The folder tree structure.
+     */
+    folderTree: () => Effect.Effect<import("../../types.js").FolderNode[], DBCallbackFailure | DatabaseError | FolderTreeError, never>;
+    /**
+     * Retrieves a list of folders.
+     *
+     * @returns An array of folder records.
+     */
+    folderList: () => Effect.Effect<import("../../types.js").FolderListItem[], DBCallbackFailure | DatabaseError, never>;
+    /**
+     * Retrieves the site configuration.
+     *
+     * @returns The site configuration object.
+     */
+    siteConfig: <T extends import("../../types.js").StudioCMSSiteConfig>() => Effect.Effect<import("../../types.js").DynamicConfigEntry<T> | undefined, import("effect/Cause").UnknownException | DBCallbackFailure | DatabaseError, never>;
+    /**
+     * Retrieves the latest version of StudioCMS from NPM.
+     *
+     * @returns The latest version string.
+     */
+    latestVersion: () => Effect.Effect<{
+        version: string;
+        lastCacheUpdate: Date;
+    }, import("effect/Cause").UnknownException | ParseResult.ParseError | import("../util/getFromNPM.js").GetFromNPMError, never>;
+    /**
+     * Retrieves all pages.
+     *
+     * @returns An array of page data records.
+     */
+    pages: {
+        (includeDrafts?: boolean, metaOnly?: false, paginate?: PaginateInput): Effect.Effect<CombinedPageData[], ParseResult.ParseError | DBCallbackFailure | DatabaseError | FolderTreeError | CollectorError | PaginateError, never>;
+        (includeDrafts?: boolean, metaOnly?: true, paginate?: PaginateInput): Effect.Effect<MetaOnlyPageData[], ParseResult.ParseError | DBCallbackFailure | DatabaseError | FolderTreeError | CollectorError | PaginateError, never>;
+    };
+    /**
+     * Utilities to get pages by specific criteria.
+     */
+    page: {
+        /**
+         * Retrieves a page by its ID.
+         *
+         * @param id - The ID of the page to fetch.
+         * @returns The page data record if found, otherwise undefined.
+         */
+        byId: {
+            (id: string): Effect.Effect<CombinedPageData | undefined, ParseResult.ParseError | DBCallbackFailure | DatabaseError | FolderTreeError | CollectorError | PaginateError, never>;
+            (id: string, metaOnly?: boolean): Effect.Effect<MetaOnlyPageData | undefined, ParseResult.ParseError | DBCallbackFailure | DatabaseError | FolderTreeError | CollectorError | PaginateError, never>;
+        };
+        /**
+         * Retrieves a page by its slug.
+         *
+         * @param slug - The slug of the page to fetch.
+         * @returns The page data record if found, otherwise undefined.
+         */
+        bySlug: {
+            (slug: string): Effect.Effect<CombinedPageData | undefined, ParseResult.ParseError | DBCallbackFailure | DatabaseError | FolderTreeError | CollectorError | PaginateError, never>;
+            (slug: string, metaOnly?: boolean): Effect.Effect<MetaOnlyPageData | undefined, ParseResult.ParseError | DBCallbackFailure | DatabaseError | FolderTreeError | CollectorError | PaginateError, never>;
+        };
+    };
+    /**
+     * Retrieves pages associated with a specific package.
+     *
+     * @param packageName - The name of the package to fetch pages for.
+     * @returns An array of page data records associated with the specified package.
+     */
+    packagePages: {
+        (packageName: string): Effect.Effect<CombinedPageData[], ParseResult.ParseError | DBCallbackFailure | DatabaseError | FolderTreeError | CollectorError | PaginateError, never>;
+        (packageName: string, metaOnly?: boolean): Effect.Effect<MetaOnlyPageData[], ParseResult.ParseError | DBCallbackFailure | DatabaseError | FolderTreeError | CollectorError | PaginateError, never>;
+    };
+    /**
+     * Retrieves pages within a specific folder.
+     *
+     * @param idOrName - The ID or name of the folder.
+     * @returns An array of page data records within the specified folder.
+     */
+    folderPages: {
+        (idOrName: string, includeDrafts?: boolean, metaOnly?: false, paginate?: PaginateInput): Effect.Effect<CombinedPageData[], ParseResult.ParseError | DBCallbackFailure | DatabaseError | FolderTreeError | CollectorError | PaginateError, never>;
+        (idOrName: string, includeDrafts?: boolean, metaOnly?: true, paginate?: PaginateInput): Effect.Effect<MetaOnlyPageData[], ParseResult.ParseError | DBCallbackFailure | DatabaseError | FolderTreeError | CollectorError | PaginateError, never>;
+    };
+    /**
+     * Retrieves the page folder tree structure.
+     *
+     * @returns The page folder tree structure.
+     */
+    pageFolderTree: (excludeDrafts?: boolean) => Effect.Effect<import("../../types.js").FolderNode[], ParseResult.ParseError | DBCallbackFailure | import("@withstudiocms/kysely/core/errors").QueryParseError | import("@withstudiocms/kysely/core/errors").QueryError | import("@withstudiocms/kysely/core/errors").NotFoundError | FolderTreeError | CollectorError | PaginateError, never>;
+    /**
+     * Category-related GET operations.
+     */
+    categories: {
+        /**
+         * Retrieves all categories.
+         *
+         * @returns An array of category records.
+         */
+        getAll: () => Effect.Effect<readonly {
+            readonly id: number;
+            readonly name: string;
+            readonly description: string;
+            readonly parent?: number | null | undefined;
+            readonly slug: string;
+            readonly meta: {
+                readonly [x: string]: unknown;
+            };
+        }[], DBCallbackFailure | DatabaseError, never>;
+        /**
+         * Retrieves a category by its ID.
+         *
+         * @param categoryId - The ID of the category to fetch.
+         * @returns The category record if found, otherwise undefined.
+         */
+        byId: (categoryId: number) => Effect.Effect<{
+            readonly id: number;
+            readonly name: string;
+            readonly description: string;
+            readonly parent?: number | null | undefined;
+            readonly slug: string;
+            readonly meta: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined, DBCallbackFailure | DatabaseError, never>;
+        /**
+         * Retrieves a category by its slug.
+         *
+         * @param slug - The slug of the category to fetch.
+         * @returns The category record if found, otherwise undefined.
+         */
+        bySlug: (slug: string) => Effect.Effect<{
+            readonly id: number;
+            readonly name: string;
+            readonly description: string;
+            readonly parent?: number | null | undefined;
+            readonly slug: string;
+            readonly meta: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined, DBCallbackFailure | DatabaseError, never>;
+    };
+    /**
+     * Tag-related GET operations.
+     */
+    tags: {
+        /**
+         * Retrieves all tags.
+         *
+         * @returns An array of tag records.
+         */
+        getAll: () => Effect.Effect<readonly {
+            readonly id: number;
+            readonly name: string;
+            readonly description: string;
+            readonly slug: string;
+            readonly meta: {
+                readonly [x: string]: unknown;
+            };
+        }[], DBCallbackFailure | DatabaseError, never>;
+        /**
+         * Retrieves a tag by its ID.
+         *
+         * @param tagId - The ID of the tag to fetch.
+         * @returns The tag record if found, otherwise undefined.
+         */
+        byId: (tagId: number) => Effect.Effect<{
+            readonly id: number;
+            readonly name: string;
+            readonly description: string;
+            readonly slug: string;
+            readonly meta: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined, DBCallbackFailure | DatabaseError, never>;
+        /**
+         * Retrieves a tag by its slug.
+         *
+         * @param slug - The slug of the tag to fetch.
+         * @returns The tag record if found, otherwise undefined.
+         */
+        bySlug: (slug: string) => Effect.Effect<{
+            readonly id: number;
+            readonly name: string;
+            readonly description: string;
+            readonly slug: string;
+            readonly meta: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined, DBCallbackFailure | DatabaseError, never>;
+    };
+}, never, DBClientLive | SDKDefaults | import("../../context.js").StorageManagerResolver | CacheService | import("@withstudiocms/effect").Deepmerge>;
+export default SDKGetModule;