katecms 0.0.0-stage → 1.0.0-beta.1

package/dist/runtime/server/utils/upload-headers.d.ts

@@ -0,0 +1,2 @@
+/** Headers for a stored upload. SVG and similar types are downloads, not pages. */
+export declare function uploadResponseHeaders(key: string): Record<string, string>;

package/dist/runtime/server/utils/upload-headers.js

@@ -0,0 +1,30 @@
+import { extname } from "node:path";
+const MIME_BY_EXT = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".avif": "image/avif",
+  ".pdf": "application/pdf",
+  ".mp4": "video/mp4",
+  ".mp3": "audio/mpeg"
+};
+const DOWNLOAD_EXTS = /* @__PURE__ */ new Set([".svg", ".html", ".htm", ".xhtml", ".xml", ".pdf"]);
+function downloadName(key) {
+  const base = key.split(/[/\\]/).pop() || "download";
+  return base.replace(/[\r\n"]/g, "") || "download";
+}
+export function uploadResponseHeaders(key) {
+  const ext = extname(key).toLowerCase();
+  const mime = MIME_BY_EXT[ext] || "application/octet-stream";
+  const disposition = DOWNLOAD_EXTS.has(ext) || mime === "application/octet-stream" ? "attachment" : "inline";
+  return {
+    "X-Content-Type-Options": "nosniff",
+    "Content-Security-Policy": "sandbox; default-src 'none'",
+    "Content-Disposition": `${disposition}; filename="${downloadName(key)}"`,
+    "Content-Type": mime,
+    "Cache-Control": "public, max-age=31536000, immutable"
+  };
+}

package/dist/runtime/server/utils/users.d.ts

@@ -0,0 +1,13 @@
+import type { MediaItem, RoleMap, User } from '@katecms/core';
+import type { AdminUser, RoleOption } from '../../utils/admin-users.js';
+export declare function fail(statusCode: number, message: string): never;
+export declare function toAdminUser(user: User): AdminUser;
+export declare function roleOptions(roles: RoleMap): RoleOption[];
+/** Role assigned when the create payload omits `role`. */
+export declare function defaultAssignableRole(roles: RoleMap): string;
+export declare function readName(value: unknown): string | null;
+/**
+ * Parse an optional avatar payload: a media item, or null to clear.
+ * Empty / missing values become null; malformed payloads are rejected.
+ */
+export declare function readAvatar(value: unknown): MediaItem | null;

package/dist/runtime/server/utils/users.js

@@ -0,0 +1,47 @@
+import { createError } from "h3";
+import {
+  ADMIN_ROLE,
+  isImageMedia,
+  isMediaItem,
+  isValidRole,
+  SUBSCRIBER_ROLE,
+  toUserFieldValue
+} from "@katecms/core";
+const STATUS_PHRASE = {
+  400: "Bad Request",
+  403: "Forbidden",
+  404: "Not Found",
+  409: "Conflict",
+  422: "Unprocessable Entity"
+};
+export function fail(statusCode, message) {
+  throw createError({
+    statusCode,
+    statusMessage: STATUS_PHRASE[statusCode] ?? "Error",
+    message
+  });
+}
+export function toAdminUser(user) {
+  return toUserFieldValue(user);
+}
+export function roleOptions(roles) {
+  return Object.values(roles).map((role) => ({ slug: role.slug, label: role.label }));
+}
+export function defaultAssignableRole(roles) {
+  if (isValidRole(roles, SUBSCRIBER_ROLE)) {
+    return SUBSCRIBER_ROLE;
+  }
+  return ADMIN_ROLE;
+}
+export function readName(value) {
+  return typeof value === "string" && value.trim().length ? value.trim() : null;
+}
+export function readAvatar(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (!isMediaItem(value) || !isImageMedia(value) || !Number.isInteger(value.id) || value.id <= 0 || !value.filename) {
+    fail(422, "Invalid avatar.");
+  }
+  return value;
+}

package/dist/runtime/utils/admin-users.d.ts

@@ -0,0 +1,20 @@
+import type { MediaItem, UserFieldValue } from '@katecms/core';
+/** A user row in the admin UI. Same shape as a stored `user` field value. */
+export type AdminUser = UserFieldValue;
+/** A role option (slug + label) for pickers and table labels. */
+export interface RoleOption {
+    slug: string;
+    label: string;
+}
+/** Response of `GET /api/_katecms/users`. */
+export interface UsersResponse {
+    users: AdminUser[];
+    roles: RoleOption[];
+    currentUserId: number;
+    canCreate: boolean;
+    canUpdate: boolean;
+    canDelete: boolean;
+}
+/** Prefer a compact image variant for avatars, then the original URL. */
+export declare function avatarSrc(avatar: MediaItem | null | undefined): string | null;
+export declare function userInitials(user: Pick<AdminUser, 'name' | 'email'>): string;

package/dist/runtime/utils/admin-users.js

@@ -0,0 +1,19 @@
+import { isImageMedia } from "@katecms/core";
+export function avatarSrc(avatar) {
+  if (!avatar || !isImageMedia(avatar)) {
+    return null;
+  }
+  const preferred = avatar.variants?.find((variant) => variant.size === "thumbnail") ?? avatar.variants?.find((variant) => variant.size === "medium");
+  return preferred?.url || avatar.url || null;
+}
+export function userInitials(user) {
+  const name = user.name?.trim();
+  if (name) {
+    const parts = name.split(/\s+/).filter(Boolean);
+    if (parts.length >= 2) {
+      return `${parts[0][0]}${parts[1][0]}`.toUpperCase();
+    }
+    return name.slice(0, 2).toUpperCase();
+  }
+  return (user.email[0] || "?").toUpperCase();
+}

package/dist/runtime/utils/auth-error.d.ts

@@ -0,0 +1,6 @@
+export interface AuthClientError {
+    message: string;
+    retryAfterMs: number;
+}
+/** Pull statusMessage / retryAfterMs out of a `$fetch` / h3 error payload. */
+export declare function parseAuthError(err: unknown, fallback: string): AuthClientError;

package/dist/runtime/utils/auth-error.js

@@ -0,0 +1,11 @@
+function asRecord(value) {
+  return value && typeof value === "object" ? value : {};
+}
+export function parseAuthError(err, fallback) {
+  const root = asRecord(err);
+  const data = asRecord(root.data);
+  const inner = asRecord(data.data);
+  const message = [inner.message, data.message, inner.statusMessage, data.statusMessage, root.statusMessage].find((value) => typeof value === "string" && value.length > 0) ?? fallback;
+  const retryAfterMs = [inner.retryAfterMs, data.retryAfterMs].find((value) => typeof value === "number" && value > 0) ?? 0;
+  return { message, retryAfterMs };
+}

package/dist/runtime/utils/cms-paths.d.ts

@@ -0,0 +1,5 @@
+/** Normalise a config path segment into an absolute route (`admin` → `/admin`). */
+export declare function cmsRoutePath(segment: string): string;
+/** Child of the admin route (`admin` + `login` → `/admin/login`). */
+export declare function cmsAdminChildPath(adminPath: string, segment: string): string;
+export declare function isCmsAdminPath(path: string, adminPath: string): boolean;

package/dist/runtime/utils/cms-paths.js

@@ -0,0 +1,13 @@
+export function cmsRoutePath(segment) {
+  const trimmed = String(segment ?? "").replace(/^\/+|\/+$/g, "");
+  return `/${trimmed}`;
+}
+export function cmsAdminChildPath(adminPath, segment) {
+  const root = cmsRoutePath(adminPath).replace(/\/$/, "");
+  const child = String(segment ?? "").replace(/^\/+|\/+$/g, "");
+  return child ? `${root}/${child}` : root;
+}
+export function isCmsAdminPath(path, adminPath) {
+  const root = cmsRoutePath(adminPath);
+  return path === root || path.startsWith(`${root}/`);
+}

package/dist/runtime/utils/collections.d.ts

@@ -0,0 +1,176 @@
+import type { CollectionStatus, CollectionStatusCounts, Fields } from '@katecms/core';
+/** Collection definition exposed to the admin UI (from CMS config). */
+export interface AdminCollectionMeta {
+    slug: string;
+    labels: {
+        name: string;
+        singularName: string;
+    };
+    hierarchical: boolean;
+    autosave: boolean;
+    /** `false` only when the collection config sets `revisions: false`. */
+    revisions: boolean;
+    public: boolean;
+    has_archive: boolean | string;
+    perPage: number;
+    rewrite?: string;
+    fields: Fields;
+}
+/** Assigned dictionary term on a public collection entry. */
+export interface PublicDictionaryTerm {
+    id: number;
+    type: string;
+    slug: string;
+    slugPath: string;
+    title: string;
+    fields: Record<string, unknown>;
+    parentId: number | null;
+}
+/** A collection entry as shown in the admin UI and public resolve. */
+export interface AdminEntry {
+    id: number;
+    type: string;
+    status: CollectionStatus;
+    slug: string;
+    slugPath: string;
+    title: string;
+    fields: Record<string, unknown>;
+    parentId: number | null;
+    /** Nesting level in a hierarchical list (0 = top-level). */
+    depth?: number;
+    menuOrder: number;
+    authorId: number | null;
+    /** Display name for the list (name, else email). Null when unknown. */
+    authorName?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    publishedAt: string | null;
+    canUpdate?: boolean;
+    canDelete?: boolean;
+    /** Selected term ids keyed by dictionary slug. */
+    dictionaryIds?: Record<string, number[]>;
+    /** Assigned terms keyed by dictionary slug (public resolve). */
+    dictionaries?: Record<string, PublicDictionaryTerm[]>;
+}
+/** One saved version of a collection entry, without the field payload. */
+export interface EntryRevisionItem {
+    id: number;
+    createdAt: string;
+    authorName: string;
+    title: string;
+    status: CollectionStatus;
+}
+export interface ParentOption {
+    id: number;
+    title: string;
+    slug: string;
+    parentId: number | null;
+    slugPath: string;
+    depth: number;
+}
+/** Dictionary attached to a collection, with terms for the entry sidebar picker. */
+export interface CollectionDictionaryPicker {
+    slug: string;
+    labels: {
+        name: string;
+        singularName: string;
+    };
+    multiple: boolean;
+    terms: ParentOption[];
+}
+export interface CollectionListResponse {
+    collection: AdminCollectionMeta;
+    entries: AdminEntry[];
+    counts: CollectionStatusCounts;
+    /** `YYYY-MM` months that contain entries for the current status and search. */
+    months?: string[];
+    page: number;
+    perPage: number;
+    total: number;
+    canCreate: boolean;
+    canUpdate: boolean;
+    canDelete: boolean;
+    parents?: ParentOption[];
+    dictionaries?: CollectionDictionaryPicker[];
+}
+export interface CollectionEntryResponse {
+    collection: AdminCollectionMeta;
+    entry: AdminEntry;
+    canUpdate: boolean;
+    canDelete: boolean;
+    parents?: ParentOption[];
+    dictionaries?: CollectionDictionaryPicker[];
+}
+export interface ResolveEntryResponse {
+    kind: 'entry';
+    collection: AdminCollectionMeta;
+    entry: AdminEntry;
+    /** True when unpublished statuses were actually allowed for this request. */
+    preview: boolean;
+}
+export interface ResolveArchiveResponse {
+    kind: 'archive';
+    collection: AdminCollectionMeta;
+    entries: AdminEntry[];
+    /** True when unpublished statuses were actually allowed for this request. */
+    preview: boolean;
+    page: number;
+    perPage: number;
+    total: number;
+}
+export interface PublicTermEntry {
+    id: number;
+    title: string;
+    path: string;
+}
+export interface ResolveTermResponse {
+    kind: 'term';
+    dictionary: {
+        slug: string;
+        labels: {
+            name: string;
+            singularName: string;
+        };
+    };
+    term: PublicDictionaryTerm;
+    entries: PublicTermEntry[];
+    path: string;
+}
+export type ResolveResponse = ResolveEntryResponse | ResolveArchiveResponse | ResolveTermResponse;
+/** Public list from `/api/_katecms/query`. */
+export interface QueryCollectionResponse {
+    entries: AdminEntry[];
+    collections: AdminCollectionMeta[];
+    /** True when unpublished statuses were actually allowed for this request. */
+    preview: boolean;
+    page: number;
+    perPage: number;
+    total: number;
+}
+export interface CollectionEntryFormModel {
+    title: string;
+    slug: string;
+    status: CollectionStatus;
+    parentId: number | null;
+    menuOrder: number;
+    publishedAt: string | null;
+    authorId: number | null;
+    fields: Record<string, unknown>;
+    /** Single: `number | null`. Multiple: `number[]`. */
+    dictionaryIds: Record<string, number | number[] | null>;
+}
+export type CollectionListFilter = 'all' | CollectionStatus;
+export declare function collectionApi(slug: string, id?: number | 'trash'): string;
+export declare function collectionStatusLabel(status: CollectionStatus): string;
+export declare function emptyDictionarySelection(pickers: CollectionDictionaryPicker[]): Record<string, number | number[] | null>;
+export declare function formDictionarySelection(pickers: CollectionDictionaryPicker[], ids: Record<string, number[]> | undefined): Record<string, number | number[] | null>;
+/** Slim collection descriptors sent on `public.katecms.collections` (sidebar). */
+export interface PublicCollectionNav {
+    labels: {
+        name: string;
+        singularName: string;
+    };
+    icon?: string;
+    public?: boolean;
+    has_archive?: boolean | string;
+}

package/dist/runtime/utils/collections.js

@@ -0,0 +1,30 @@
+export function collectionApi(slug, id) {
+  const base = `/api/_katecms/collections/${encodeURIComponent(slug)}`;
+  if (id == null) {
+    return base;
+  }
+  return `${base}/${id}`;
+}
+export function collectionStatusLabel(status) {
+  if (status === "published") {
+    return "Published";
+  }
+  if (status === "draft") {
+    return "Draft";
+  }
+  return "Trash";
+}
+export function emptyDictionarySelection(pickers) {
+  return Object.fromEntries(
+    pickers.map((picker) => [picker.slug, picker.multiple ? [] : null])
+  );
+}
+export function formDictionarySelection(pickers, ids) {
+  const selected = ids ?? {};
+  return Object.fromEntries(
+    pickers.map((picker) => {
+      const values = selected[picker.slug] ?? [];
+      return [picker.slug, picker.multiple ? values : values[0] ?? null];
+    })
+  );
+}

package/dist/runtime/utils/dictionaries.d.ts

@@ -0,0 +1,65 @@
+import type { Fields } from '@katecms/core';
+import type { ParentOption } from './collections.js';
+export type { ParentOption };
+/** Dictionary type exposed to the admin UI (from CMS config). */
+export interface AdminDictionaryMeta {
+    slug: string;
+    labels: {
+        name: string;
+        singularName: string;
+    };
+    fields: Fields;
+    collections: string[];
+    multiple: boolean;
+    hierarchical: boolean;
+    public: boolean;
+    rewrite?: string;
+}
+/** A dictionary term as shown in the admin UI. */
+export interface AdminDictionaryTerm {
+    id: number;
+    type: string;
+    slug: string;
+    slugPath: string;
+    title: string;
+    fields: Record<string, unknown>;
+    parentId: number | null;
+    /** Nesting level in a hierarchical list (0 = top-level). */
+    depth?: number;
+    createdAt: string;
+    updatedAt: string;
+    canUpdate?: boolean;
+    canDelete?: boolean;
+}
+export interface DictionaryListResponse {
+    dictionary: AdminDictionaryMeta;
+    terms: AdminDictionaryTerm[];
+    parents: ParentOption[];
+    canCreate: boolean;
+    canUpdate: boolean;
+    canDelete: boolean;
+}
+export interface DictionaryTermResponse {
+    dictionary: AdminDictionaryMeta;
+    term: AdminDictionaryTerm;
+    canUpdate: boolean;
+    canDelete: boolean;
+    parents: ParentOption[];
+}
+export interface DictionaryTermFormModel {
+    title: string;
+    slug: string;
+    parentId: number | null;
+    fields: Record<string, unknown>;
+}
+/** Slim dictionary descriptors sent on `public.katecms.dictionaries` (sidebar). */
+export interface PublicDictionaryNav {
+    labels: {
+        name: string;
+        singularName: string;
+    };
+    icon?: string;
+}
+/** Public term URL, or `null` when the dictionary is not public. */
+export declare function dictionaryTermUrl(dictionary: Pick<AdminDictionaryMeta, 'slug' | 'public' | 'rewrite'>, slugPath: string): string | null;
+export declare function dictionaryApi(slug: string, id?: number): string;

package/dist/runtime/utils/dictionaries.js

@@ -0,0 +1,14 @@
+import { buildPublicPath } from "@katecms/core";
+export function dictionaryTermUrl(dictionary, slugPath) {
+  if (!dictionary.public || !slugPath) {
+    return null;
+  }
+  return buildPublicPath(dictionary.rewrite, dictionary.slug, slugPath);
+}
+export function dictionaryApi(slug, id) {
+  const base = `/api/_katecms/dictionaries/${encodeURIComponent(slug)}`;
+  if (id == null) {
+    return base;
+  }
+  return `${base}/${id}`;
+}

package/dist/runtime/utils/field-errors.d.ts

@@ -0,0 +1,4 @@
+import { type ComputedRef, type InjectionKey, type Ref } from 'vue';
+export declare const miraiCmsFieldErrorsKey: InjectionKey<Ref<Record<string, string>>>;
+export declare function provideKateCmsFieldErrors(errors: Ref<Record<string, string>>): void;
+export declare function useKateCmsFieldError(fieldKey: () => string): ComputedRef<string>;

package/dist/runtime/utils/field-errors.js

@@ -0,0 +1,9 @@
+import { computed, inject, provide } from "vue";
+export const miraiCmsFieldErrorsKey = Symbol("katecmsFieldErrors");
+export function provideKateCmsFieldErrors(errors) {
+  provide(miraiCmsFieldErrorsKey, errors);
+}
+export function useKateCmsFieldError(fieldKey) {
+  const errors = inject(miraiCmsFieldErrorsKey, null);
+  return computed(() => errors?.value[fieldKey()] ?? "");
+}

package/dist/runtime/utils/field-values.d.ts

@@ -0,0 +1,19 @@
+import { type InjectionKey, type Ref } from 'vue';
+/**
+ * Parent form / group values for layout-only fields (`tab`, `accordion`).
+ * May be a reactive object or a ref to one (e.g. group `defineModel`).
+ */
+export type KateCmsFieldValuesStore = Ref<Record<string, unknown>> | Record<string, unknown>;
+export declare const miraiCmsFieldValuesKey: InjectionKey<KateCmsFieldValuesStore>;
+export declare function provideKateCmsFieldValues(store: KateCmsFieldValuesStore): void;
+/**
+ * Read/write helpers for the nearest provided field-values store.
+ * Layout fields (`tab` / `accordion`) use this instead of their own v-model.
+ */
+export declare function useKateCmsFieldValues(): {
+    store: KateCmsFieldValuesStore | null;
+    getValues: () => Record<string, unknown>;
+    setValue: (key: string, value: unknown) => void;
+    ensureDefaults: (defaults: Record<string, unknown>) => void;
+    removeKey: (key: string) => void;
+};

package/dist/runtime/utils/field-values.js

@@ -0,0 +1,82 @@
+import { inject, isRef, provide } from "vue";
+export const miraiCmsFieldValuesKey = Symbol("miraiCmsFieldValues");
+export function provideKateCmsFieldValues(store) {
+  provide(miraiCmsFieldValuesKey, store);
+}
+function readStore(store) {
+  if (!store) {
+    return {};
+  }
+  if (isRef(store)) {
+    const value = store.value;
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  }
+  return store;
+}
+export function useKateCmsFieldValues() {
+  const store = inject(miraiCmsFieldValuesKey, null);
+  function getValues() {
+    return readStore(store);
+  }
+  function setValue(key, value) {
+    if (!store) {
+      return;
+    }
+    if (isRef(store)) {
+      const current = readStore(store);
+      store.value = {
+        ...current,
+        [key]: value
+      };
+      return;
+    }
+    store[key] = value;
+  }
+  function ensureDefaults(defaults) {
+    if (!store) {
+      return;
+    }
+    if (isRef(store)) {
+      const current = { ...readStore(store) };
+      let changed = false;
+      for (const [key, value] of Object.entries(defaults)) {
+        if (!(key in current)) {
+          current[key] = value;
+          changed = true;
+        }
+      }
+      if (changed) {
+        store.value = current;
+      }
+      return;
+    }
+    for (const [key, value] of Object.entries(defaults)) {
+      if (!(key in store)) {
+        store[key] = value;
+      }
+    }
+  }
+  function removeKey(key) {
+    if (!store) {
+      return;
+    }
+    if (isRef(store)) {
+      const current = readStore(store);
+      if (!(key in current)) {
+        return;
+      }
+      const next = { ...current };
+      Reflect.deleteProperty(next, key);
+      store.value = next;
+      return;
+    }
+    Reflect.deleteProperty(store, key);
+  }
+  return {
+    store,
+    getValues,
+    setValue,
+    ensureDefaults,
+    removeKey
+  };
+}

package/dist/runtime/utils/helpers.d.ts

@@ -0,0 +1,4 @@
+import type { Component } from 'vue';
+/** Registers a field widget supplied by an addon. `type` matches the field config `type`. */
+export declare function registerKateCmsField(type: string, component: Component): void;
+export declare function resolveField(type: string): Component | undefined;

package/dist/runtime/utils/helpers.js

@@ -0,0 +1,20 @@
+const fieldModules = import.meta.glob(
+  "../internal/fields/*.vue",
+  { eager: true }
+);
+const fieldComponents = Object.fromEntries(
+  Object.entries(fieldModules).map(([path, mod]) => {
+    const name = path.split(/[/\\]/).pop().replace(/\.vue$/, "");
+    return [name, mod.default];
+  })
+);
+const extraFieldComponents = /* @__PURE__ */ new Map();
+export function registerKateCmsField(type, component) {
+  extraFieldComponents.set(type, component);
+}
+function toPascalCase(str) {
+  return str.split(/[_\-\s]+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+export function resolveField(type) {
+  return fieldComponents[`${toPascalCase(type)}Field`] ?? extraFieldComponents.get(type);
+}

package/dist/runtime/utils/media-library-query.d.ts

@@ -0,0 +1,54 @@
+import type { MediaItem } from '@katecms/core';
+/** Library filter shown in the media page and file pickers. */
+export type MediaTypeFilter = 'all' | 'image' | 'audio' | 'video' | 'document' | 'spreadsheet' | 'archive';
+/** How the library list is ordered. The part after the hyphen is the direction. */
+export type MediaSort = 'date-desc' | 'date-asc' | 'author-asc' | 'author-desc' | 'name-asc' | 'name-desc' | 'filesize-desc' | 'filesize-asc' | 'dimensions-desc' | 'dimensions-asc';
+export interface MediaLibraryFilterState {
+    type: MediaTypeFilter;
+    /** `all` or `YYYY-MM`. */
+    month: string;
+    search: string;
+    sort: MediaSort;
+}
+export interface MediaLibraryPage<T> {
+    media: T[];
+    total: number;
+    /** `YYYY-MM` values that contain matches for the current type and search. */
+    months: string[];
+}
+export declare const MEDIA_TYPE_FILTERS: MediaTypeFilter[];
+export declare const MEDIA_SORTS: MediaSort[];
+export declare const MEDIA_SORT_CHOICES: {
+    val: MediaSort;
+    lbl: string;
+}[];
+export declare const MEDIA_TYPE_CHOICES: {
+    val: MediaTypeFilter;
+    lbl: string;
+}[];
+export declare const DOCUMENT_MIME_TYPES: readonly ["application/msword", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "application/vnd.ms-word.document.macroEnabled.12", "application/vnd.ms-word.template.macroEnabled.12", "application/vnd.oasis.opendocument.text", "application/vnd.apple.pages", "application/pdf", "application/vnd.ms-xpsdocument", "application/oxps", "application/rtf", "application/wordperfect", "application/octet-stream"];
+export declare const SPREADSHEET_MIME_TYPES: readonly ["application/vnd.apple.numbers", "application/vnd.oasis.opendocument.spreadsheet", "application/vnd.ms-excel", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "application/vnd.ms-excel.sheet.macroEnabled.12", "application/vnd.ms-excel.sheet.binary.macroEnabled.12"];
+export declare const ARCHIVE_MIME_TYPES: readonly ["application/x-gzip", "application/rar", "application/x-tar", "application/zip", "application/x-7z-compressed"];
+export declare function defaultMediaLibraryFilters(): MediaLibraryFilterState;
+export declare function isMediaTypeFilter(value: unknown): value is MediaTypeFilter;
+export declare function isMediaSort(value: unknown): value is MediaSort;
+export declare function normalizeMediaLibraryFilters(value: MediaLibraryFilterState): MediaLibraryFilterState;
+export declare function mediaFiltersActive(filters: MediaLibraryFilterState): boolean;
+/** Minutes to add to UTC to get the viewer's local time. */
+export declare function clampUtcOffsetMinutes(value: number): number;
+export declare function localUtcOffsetMinutes(now?: Date): number;
+export declare function monthLabel(value: string): string;
+/** Local calendar month for an ISO timestamp, as `YYYY-MM`. */
+export declare function monthKey(iso: string, offsetMinutes: number): string;
+/** Search text with LIKE wildcards removed. */
+export declare function searchNeedle(value: string): string;
+export declare function matchesMediaType(mime: string, type: MediaTypeFilter): boolean;
+export declare function mediaMatchesFilters(item: Pick<MediaItem, 'mime_type' | 'filename' | 'alt' | 'caption' | 'created_at'>, filters: MediaLibraryFilterState, offsetMinutes?: number): boolean;
+/**
+ * Query string for `GET /api/_katecms/media`.
+ * Image pickers pass `baseType: 'image'` so "All media items" still pages through images only.
+ */
+export declare function mediaLibraryQuery(filters: MediaLibraryFilterState, paging: {
+    limit: number;
+    offset: number;
+}, baseType?: 'image'): Record<string, string | number>;