rimecms 0.31.5 → 0.32.0

package/dist/core/ensure.server.d.ts

@@ -1,34 +0,0 @@
-import type { BuiltCollection } from '../types.js';
-/**
- * Ensure sanitize config exists — the generated server config inside the generated config dir.
- */
-export declare function ensureGeneratedConfig(): string;
-/**
- * Ensure user config exists — the CONFIG_DIR folder convention.
- */
-export declare function ensureUserConfigExist(): void;
-/**
- * Ensure schema exists (see adapter-sqlite/generate-schema/write.server.ts, which writes to
- * the same path).
- */
-export declare function ensureSchema(): void;
-/**
- * Ensure .env exists
- */
-export declare function ensureEnv(): void;
-/**
- * Ensure drizzle config exists
- */
-export declare function ensureDirzzle(): void;
-/**
- * Ensure hooks.server exists
- */
-export declare function ensureHooks(): void;
-/**
- * Ensure db directory exists
- */
-export declare function ensureDatabase(): void;
-export declare function ensureMedias<C extends {
-    collections?: BuiltCollection[];
-}>(config: C): void;
-export declare const ensureHasInit: () => void;

package/dist/core/ensure.server.js

@@ -1,91 +0,0 @@
-import { existsSync, mkdirSync } from 'node:fs';
-import path from 'node:path';
-import { CONFIG_DIR, GENERATED_DIR, generatedConfigServerPath, schemaPath } from './dev/constants.js';
-const projectRoot = process.cwd();
-/**
- * Ensure sanitize config exists — the generated server config inside the generated config dir.
- */
-export function ensureGeneratedConfig() {
-    const configGeneratedPath = path.resolve(projectRoot, GENERATED_DIR, 'rime.config.server.ts');
-    if (!existsSync(configGeneratedPath)) {
-        throw new Error('Unable to find generated config');
-    }
-    return generatedConfigServerPath();
-}
-/**
- * Ensure user config exists — the CONFIG_DIR folder convention.
- */
-export function ensureUserConfigExist() {
-    const folderConfig = path.resolve(projectRoot, CONFIG_DIR, 'rime.config.server.ts');
-    if (existsSync(folderConfig))
-        return;
-    // Every project set up before RIME_CONFIG_DIR existed has its config here — if it's there
-    // but not at CONFIG_DIR, this is almost certainly an upgrade whose .env predates the env
-    // var, not a missing init, so say that instead of the generic message.
-    const LEGACY_DEFAULT = 'src/lib/+rime';
-    if (CONFIG_DIR !== LEGACY_DEFAULT &&
-        existsSync(path.resolve(projectRoot, LEGACY_DEFAULT, 'rime.config.server.ts'))) {
-        throw new Error(`Unable to find config at ${CONFIG_DIR} — found one at ${LEGACY_DEFAULT} instead. ` +
-            `Set RIME_CONFIG_DIR=${LEGACY_DEFAULT} in your .env to keep using it there, or move it to ${CONFIG_DIR} to match the current default.`);
-    }
-    throw new Error('Unable to find config, did you run rime init');
-}
-/**
- * Ensure schema exists (see adapter-sqlite/generate-schema/write.server.ts, which writes to
- * the same path).
- */
-export function ensureSchema() {
-    if (!existsSync(schemaPath(projectRoot))) {
-        throw new Error('Unable to find schema, did you run rime init');
-    }
-}
-/**
- * Ensure .env exists
- */
-export function ensureEnv() {
-    const envFile = path.resolve(projectRoot, './.env');
-    if (!existsSync(envFile))
-        throw new Error('Missing .env file');
-}
-/**
- * Ensure drizzle config exists
- */
-export function ensureDirzzle() {
-    const drizzleConfigFile = path.resolve(projectRoot, './drizzle.config.ts');
-    if (!existsSync(drizzleConfigFile))
-        throw new Error('Missing drizzle.config.ts file');
-}
-/**
- * Ensure hooks.server exists
- */
-export function ensureHooks() {
-    const hooksServerFile = path.resolve(projectRoot, './src/hooks.server.ts');
-    if (!existsSync(hooksServerFile))
-        throw new Error('Missing src/hooks.server.ts file');
-}
-/**
- * Ensure db directory exists
- */
-export function ensureDatabase() {
-    const dbDirectory = path.resolve(projectRoot, './db');
-    if (!existsSync(dbDirectory))
-        throw new Error('Missing db directory');
-}
-export function ensureMedias(config) {
-    const hasUpload = (config.collections || []).some((collection) => !!collection.upload);
-    if (hasUpload) {
-        const mediasDirectory = path.resolve(process.cwd(), 'static/medias');
-        if (!existsSync(mediasDirectory)) {
-            mkdirSync(mediasDirectory, { recursive: true });
-        }
-    }
-}
-export const ensureHasInit = () => {
-    ensureEnv();
-    ensureDirzzle();
-    ensureHooks();
-    ensureDatabase();
-    ensureUserConfigExist();
-    ensureGeneratedConfig();
-    ensureSchema();
-};

package/dist/core/handlers/auth.server.js

@@ -1,162 +0,0 @@
-import { isPublicPanelAuthRoute } from '../constant.js';
-import { RimeError } from '../errors/index.js';
-import { error, redirect } from '@sveltejs/kit';
-import { BETTER_AUTH_ROLES } from '../collections/auth/constant.server.js';
-import { logger } from '../logger/index.server.js';
-const dev = process.env.NODE_ENV === 'development';
-/**
- * Analyzes the current route to determine authentication requirements.
- * isPanel/isPublicAuthRoute are derived from the matched route, not the
- * pathname — event.params.panel only resolves when the request matched the
- * [panel=panel] matcher, and event.route.id's literal folder names never
- * carry the configured RIME_PANEL_ROUTE value — so neither check needs to
- * know the actual (hideable) panel segment. sign-in/forgot-password/reset-password
- * all live under [panel=panel] too but must stay reachable without a session,
- * hence the isPublicAuthRoute carve-out.
- */
-function analyzeRoute(event) {
-    const isPublicAuthRoute = isPublicPanelAuthRoute(event.route.id);
-    const isPanel = event.params.panel !== undefined && !isPublicAuthRoute;
-    const isAPI = event.url.pathname.startsWith('/api');
-    return { isPublicAuthRoute, isPanel, isAPI };
-}
-/**
- * Ensures panel is properly set up before allowing access
- */
-async function ensureFirstAuthSetup(rime) {
-    if (!(await rime.adapter.auth.hasAuthUser()) && !dev) {
-        throw new RimeError(RimeError.NOT_FOUND);
-    }
-}
-/**
- * Authenticates the request using better-auth
- */
-async function authenticateRequest(headers, auth) {
-    return await auth.api.getSession({ headers });
-}
-/**
- * Handles unauthenticated users based on route requirements
- */
-function handleUnauthenticated(event, resolve, routeInfo) {
-    if (routeInfo.isPanel) {
-        throw redirect(303, `/${event.params.panel}/sign-in`);
-    }
-    event.locals.user = undefined;
-    event.locals.session = undefined;
-    return resolve(event);
-}
-/**
- * Gets CMS user attributes for the authenticated user
- */
-async function getCmsUserAttributes(authUserId, userType, rime) {
-    const user = await rime.adapter.auth.getUserAttributes({
-        authUserId,
-        slug: userType
-    });
-    if (!user) {
-        logger.error(RimeError.UNAUTHORIZED);
-        throw error(401, RimeError.UNAUTHORIZED);
-    }
-    return user;
-}
-/**
- * Validates admin roles consistency between better-auth and CMS
- */
-function validateAdminRoles(user, authUser) {
-    if (user.roles.includes('admin') && authUser.role !== BETTER_AUTH_ROLES.ADMIN) {
-        logger.error(RimeError.UNAUTHORIZED);
-        throw error(401, RimeError.UNAUTHORIZED);
-    }
-}
-/**
- * Handles API key authentication and role forwarding
- */
-async function handleApiKeyAuth(headers, user, auth) {
-    const apiKey = headers.get('x-api-key');
-    if (!apiKey)
-        return;
-    const result = await auth.api.verifyApiKey({
-        body: { key: apiKey }
-    });
-    if (!result.valid || !result.key || !result.key.permissions) {
-        logger.error(RimeError.UNAUTHORIZED, 'Invalid api key');
-        throw error(401, RimeError.UNAUTHORIZED);
-    }
-    user.roles = result.key.permissions.roles;
-}
-/**
- * Builds complete user data by combining auth and CMS information
- */
-async function buildUserData(authResult, rime, headers) {
-    const { session, user: authUser } = authResult;
-    // Get CMS user attributes
-    const user = await getCmsUserAttributes(authUser.id, authUser.type, rime);
-    // Validate admin roles consistency
-    validateAdminRoles(user, authUser);
-    // Handle API key authentication
-    await handleApiKeyAuth(headers, user, rime.auth);
-    return { user, session, authUser };
-}
-/**
- * Applies authorization rules based on route and user data
- */
-function authorizePanelUser(userData, routeInfo, config) {
-    const { user } = userData;
-    // Panel-specific authorization
-    if (routeInfo.isPanel) {
-        // Do not allow non-staff user on panel
-        if (!user.isStaff) {
-            logger.error(RimeError.UNAUTHORIZED);
-            throw error(401, RimeError.UNAUTHORIZED);
-        }
-        if (!config.raw.panel.$access(user)) {
-            logger.error(RimeError.UNAUTHORIZED);
-            throw error(401, RimeError.UNAUTHORIZED);
-        }
-    }
-}
-/**
- * Sets up event locals and resolves the request
- */
-function setupLocalsAndResolve(event, resolve, userData) {
-    const { user, session, authUser } = userData;
-    event.locals.user = user;
-    event.locals.session = session || undefined;
-    event.locals.betterAuthUser = authUser;
-    return resolve(event);
-}
-/**
- * Clean up user props
- */
-function cleanupUser(userData, routeInfo) {
-    if (!routeInfo.isPanel && !routeInfo.isAPI) {
-        delete userData.user.isSuperAdmin;
-        delete userData.user.isStaff;
-    }
-    return userData;
-}
-/**
- * Main authentication handler with clear, linear flow
- */
-export const handleAuth = async ({ event, resolve }) => {
-    const rime = event.locals.rime;
-    const routeInfo = analyzeRoute(event);
-    // Ensure auth is set up
-    if (routeInfo.isPanel) {
-        await ensureFirstAuthSetup(rime);
-    }
-    // Authenticate the request
-    const authResult = await authenticateRequest(event.request.headers, rime.auth);
-    // Handle unauthenticated users
-    if (!authResult) {
-        return handleUnauthenticated(event, resolve, routeInfo);
-    }
-    // Build complete user data
-    let userData = await buildUserData(authResult, rime, event.request.headers);
-    // Apply panel authorization rules
-    authorizePanelUser(userData, routeInfo, rime.config);
-    // Filter user props if not on panel or API
-    userData = cleanupUser(userData, routeInfo);
-    // Set up locals and resolve
-    return setupLocalsAndResolve(event, resolve, userData);
-};

package/dist/core/handlers/cors.server.js

@@ -1,73 +0,0 @@
-import { RimeError } from '../errors/index.js';
-import { logger } from '../logger/index.server.js';
-import { error } from '@sveltejs/kit';
-/**
- * Validates if the origin is in the trusted origins list
- */
-function isOriginTrusted(origin, trustedOrigins) {
-    return trustedOrigins.includes(origin);
-}
-/**
- * Handles preflight OPTIONS requests for CORS
- */
-function handlePreflightRequest(origin) {
-    return new Response(null, {
-        status: 204,
-        headers: {
-            'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, PATCH, OPTIONS',
-            'Access-Control-Allow-Origin': origin,
-            'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-API-Key',
-            'Access-Control-Max-Age': '86400'
-        }
-    });
-}
-/**
- * Adds CORS headers to the response
- */
-function addCorsHeaders(response, origin) {
-    response.headers.set('Access-Control-Allow-Origin', origin);
-    response.headers.set('Access-Control-Allow-Credentials', 'true');
-}
-/**
- * Validates CORS for API routes with Origin header
- */
-function validateCorsOrigin(origin, trustedOrigins, pathname) {
-    if (!isOriginTrusted(origin, trustedOrigins)) {
-        logger.error(`CORS violation: Origin "${origin}" not in trusted origins for ${pathname}`);
-        throw error(403, RimeError.UNAUTHORIZED || 'CORS origin not allowed');
-    }
-}
-/**
- * Handles Cross-Origin Resource Sharing (CORS) for API routes
- *
- * Only validates CORS when Origin header is present (indicating browser cross-origin request).
- * Same-origin requests and server-to-server requests don't have Origin header and are allowed.
- */
-export const handleCORS = async ({ event, resolve }) => {
-    const { rime } = event.locals;
-    const trustedOrigins = rime.config.raw.$trustedOrigins || [];
-    const IS_API_ROUTE = event.url.pathname.startsWith('/api');
-    const IS_OPTIONS_REQUEST = event.request.method === 'OPTIONS';
-    const origin = event.request.headers.get('origin');
-    // Only handle CORS for API routes
-    if (!IS_API_ROUTE) {
-        return resolve(event);
-    }
-    // No Origin header = same-origin or server-to-server request
-    // These don't need CORS validation
-    if (!origin) {
-        return resolve(event);
-    }
-    // Origin header present = browser cross-origin request
-    // Validate the origin is trusted
-    validateCorsOrigin(origin, trustedOrigins, event.url.pathname);
-    // Handle preflight OPTIONS requests
-    if (IS_OPTIONS_REQUEST) {
-        return handlePreflightRequest(origin);
-    }
-    // Process the request
-    const response = await resolve(event);
-    // Add CORS headers for cross-origin requests
-    addCorsHeaders(response, origin);
-    return response;
-};

package/dist/core/handlers/index.d.ts

@@ -1,3 +0,0 @@
-import type { Config } from '../config/types.js';
-import type { Rime } from '../rime.server.js';
-export default function <const C extends Config>(rime: Promise<Rime<C>>): Promise<import("@sveltejs/kit").Handle[]>;

package/dist/core/handlers/index.js

@@ -1,16 +0,0 @@
-import { handleAuth } from './auth.server.js';
-import { handleCORS } from './cors.server.js';
-import { createCMSHandler } from './main.server.js';
-import { createPluginsHandler } from './plugins.server.js';
-import { handleRoutes } from './routes.server.js';
-// C -> rime(C)
-//      |-> BuildConfig<C> -> B -> async createRime<B> -> Promise<Rime<C>
-export default async function (rime) {
-    return [
-        createCMSHandler(await rime),
-        handleAuth,
-        handleCORS,
-        ...createPluginsHandler(await rime),
-        handleRoutes
-    ];
-}

package/dist/core/handlers/main.server.d.ts

@@ -1,4 +0,0 @@
-import { type Handle } from '@sveltejs/kit';
-import type { Config } from '../config/types.js';
-import type { Rime } from '../rime.server.js';
-export declare function createCMSHandler<const C extends Config>(rime: Rime<C>): Handle;

package/dist/core/handlers/main.server.js

@@ -1,14 +0,0 @@
-import { building } from '$app/environment';
-import { logger } from '../logger/index.server.js';
-import {} from '@sveltejs/kit';
-import { svelteKitHandler } from 'better-auth/svelte-kit';
-export function createCMSHandler(rime) {
-    //
-    const handleCMS = async ({ event, resolve }) => {
-        //
-        logger.info(`${event.request.method} ${event.url.pathname}`);
-        event.locals.rime = rime.createRimeContext(event);
-        return svelteKitHandler({ event, resolve, auth: rime.auth, building });
-    };
-    return handleCMS;
-}

package/dist/core/handlers/plugins.server.js

@@ -1,10 +0,0 @@
-import {} from '@sveltejs/kit';
-export function createPluginsHandler(rime) {
-    const pluginHandlers = [];
-    for (const plugin of rime.config.raw.$plugins || []) {
-        if (plugin.handler) {
-            pluginHandlers.push(plugin.handler);
-        }
-    }
-    return pluginHandlers;
-}

package/dist/core/handlers/routes.server.d.ts

@@ -1,71 +0,0 @@
-import { areaLoad } from '../../panel/pages/area/load.server.js';
-import { documentLoad } from '../../panel/pages/collection-document/load.server.js';
-import { collectionLoad } from '../../panel/pages/collection/load.server.js';
-import { liveLoad } from '../../panel/pages/live/load.server.js';
-import { checkLiveRedirect } from '../../panel/util/live.server.js';
-import { type Handle, type RequestEvent, type ServerLoadEvent } from '@sveltejs/kit';
-/**
- * Backs the fixed set of generated /panel/[slug=collection|area]/... and
- * /api/[slug=collection|area]/... routes — each of these reads slug/id off
- * event.params itself (a real dynamic route param), so the generated file
- * just passes event straight through, no import needed. The param matchers
- * (src/params/collection.ts, area.ts) already disambiguate collection vs
- * area at the router level, so rest.collection/rest.area need no runtime
- * isArea/id branching — each generated route calls the one method that
- * matches its own folder. Deliberately lives outside rime.server.ts: app
- * authors never touch this, and importing these panel/api wrappers there
- * would make RimeContext's inferred type depend on functions that read
- * event.locals.rime — i.e. on itself.
- */
-export declare const routeHandlers: {
-    checkLiveRedirect: typeof checkLiveRedirect;
-    panel: {
-        load: {
-            collection: typeof collectionLoad;
-            document: typeof documentLoad;
-            documentVersions: (event: ServerLoadEvent) => Promise<import("../../panel/index.js").CollectionDocData<true>>;
-            area: typeof areaLoad;
-            areaVersions: (event: ServerLoadEvent) => Promise<import("../../panel/index.js").AreaDocData<true>>;
-            dashboard: (event: ServerLoadEvent) => Promise<{
-                entries: import("../../panel/pages/dashboard/types.js").DashboardEntry[];
-                aria: import("../../types.js").Route[];
-            }>;
-            live: typeof liveLoad;
-            signIn: ({ locals, params }: ServerLoadEvent) => Promise<{
-                forgotPasswordEnabled: boolean;
-                image: string | null;
-                form: {};
-            }>;
-            forgotPassword: ({ locals }: ServerLoadEvent) => Promise<{
-                form: {};
-                image: string | null;
-            }>;
-            resetPassword: ({ locals, url }: ServerLoadEvent) => Promise<{
-                image: string | null;
-                token: string;
-            }>;
-        };
-        actions: {
-            document: import("@sveltejs/kit").Actions;
-            area: import("@sveltejs/kit").Actions;
-            signIn: (event: RequestEvent) => any;
-        };
-    };
-    rest: {
-        collection: {
-            get: typeof import("../collections/rest/get.server.js").restGet;
-            getById: typeof import("../collections/rest/getById.server.js").restGetById;
-            deleteById: typeof import("../collections/rest/deleteById.server.js").restDeleteById;
-            delete: typeof import("../collections/rest/delete.server.js").restDelete;
-            create: typeof import("../collections/rest/create.server.js").restCreate;
-            updateById: typeof import("../collections/rest/updateById.server.js").restUpdateById;
-            duplicate: typeof import("../collections/rest/duplicate.server.js").restDuplicate;
-        };
-        area: {
-            get: typeof import("../areas/rest/get.server.js").restGet;
-            update: typeof import("../areas/rest/update.server.js").restUpdate;
-        };
-    };
-};
-export declare const handleRoutes: Handle;
-export type RouteHandlers = typeof routeHandlers;

package/dist/core/handlers/routes.server.js

@@ -1,89 +0,0 @@
-import { isPublicPanelAuthRoute } from '../constant.js';
-import { prototypeKebabToSlug } from '../naming.js';
-import buildNavigation from '../../panel/navigation.js';
-import { areaFormActions } from '../../panel/pages/area/actions.server.js';
-import { areaLoad } from '../../panel/pages/area/load.server.js';
-import { forgotPasswordLoad } from '../../panel/pages/auth/forgot-password/load.server.js';
-import { resetPasswordLoad } from '../../panel/pages/auth/reset-password/load.server.js';
-import { signInActions } from '../../panel/pages/auth/sign-in/actions.server.js';
-import { signInLoad } from '../../panel/pages/auth/sign-in/load.server.js';
-import { collectionFormActions } from '../../panel/pages/collection-document/actions.server.js';
-import { documentLoad } from '../../panel/pages/collection-document/load.server.js';
-import { collectionLoad } from '../../panel/pages/collection/load.server.js';
-import { dashboardLoad } from '../../panel/pages/dashboard/load.server.js';
-import { liveLoad } from '../../panel/pages/live/load.server.js';
-import { checkLiveRedirect } from '../../panel/util/live.server.js';
-import {} from '@sveltejs/kit';
-import { rest as areaRest } from '../areas/rest/index.server.js';
-import { rest as collectionRest } from '../collections/rest/index.server.js';
-/**
- * Backs the fixed set of generated /panel/[slug=collection|area]/... and
- * /api/[slug=collection|area]/... routes — each of these reads slug/id off
- * event.params itself (a real dynamic route param), so the generated file
- * just passes event straight through, no import needed. The param matchers
- * (src/params/collection.ts, area.ts) already disambiguate collection vs
- * area at the router level, so rest.collection/rest.area need no runtime
- * isArea/id branching — each generated route calls the one method that
- * matches its own folder. Deliberately lives outside rime.server.ts: app
- * authors never touch this, and importing these panel/api wrappers there
- * would make RimeContext's inferred type depend on functions that read
- * event.locals.rime — i.e. on itself.
- */
-export const routeHandlers = {
-    checkLiveRedirect,
-    panel: {
-        load: {
-            collection: collectionLoad,
-            document: documentLoad,
-            documentVersions: (event) => documentLoad(event, true),
-            area: areaLoad,
-            areaVersions: (event) => areaLoad(event, true),
-            dashboard: dashboardLoad,
-            live: liveLoad,
-            signIn: signInLoad,
-            forgotPassword: forgotPasswordLoad,
-            resetPassword: resetPasswordLoad
-        },
-        actions: {
-            document: collectionFormActions,
-            area: areaFormActions,
-            signIn: signInActions.default
-        }
-    },
-    rest: {
-        collection: collectionRest,
-        area: areaRest
-    }
-};
-export const handleRoutes = async ({ event, resolve }) => {
-    const { rime, user } = event.locals;
-    const IS_PUBLIC_AUTH_ROUTE = isPublicPanelAuthRoute(event.route.id);
-    const IS_API_ROUTE = event.url.pathname.startsWith('/api');
-    const IS_PANEL_ROUTE = event.params.panel !== undefined && !IS_PUBLIC_AUTH_ROUTE;
-    // event.params.slug comes straight from the URL, always kebab-case (see
-    // src/params/collection.ts, area.ts). Collection/area slugs themselves are
-    // camelCase, so rewrite once here — every downstream handler (panel
-    // load/actions, REST) can then keep comparing event.params.slug directly
-    // against the config's `slug`. Scoped to routes actually matched via our
-    // own [slug=collection]/[slug=area] param matchers (route.id carries the
-    // matcher name) — a consumer's own app route can also use a `slug` param
-    // (e.g. (front)/pages/[slug]) and must be left untouched.
-    if ((IS_API_ROUTE || IS_PANEL_ROUTE) && event.params.slug) {
-        event.params.slug = prototypeKebabToSlug(event.params.slug);
-    }
-    // build panel navigation
-    if (IS_PANEL_ROUTE && event.request.method === 'GET') {
-        event.locals.navigation = buildNavigation(rime.config.raw, user, event.params.panel);
-    }
-    event.locals.routes = routeHandlers;
-    // Handle custom routes from config and plugins
-    const routes = '$routes' in rime.config.raw ? rime.config.raw.$routes : null;
-    if (routes && event.url.pathname in routes) {
-        const route = routes[event.url.pathname];
-        const method = event.request.method;
-        if (method in route && !!route[method]) {
-            return route[method](event);
-        }
-    }
-    return resolve(event);
-};

package/dist/core/naming.d.ts

@@ -1,82 +0,0 @@
-import type { CollectionSlug } from '../types.js';
-/**
- * Add a _directories suffix to a given name.
- * Used for uploads path slug and tables.
- * Prevent a version table name from being used, force the use of the main one.
- *
- * @example
- * // Returns both 'pages_directories'
- * withDirectoriesSuffix('pages');
- * withDirectoriesSuffix('pages_versions');
- */
-export declare const withDirectoriesSuffix: (slug: string) => CollectionSlug;
-/**
- * Remove a _directories suffix to a given name.
- * Used for uploads path slug and tables.
- * Prevent a version table name from being used, force the use of the main one.
- *
- * @example
- * // Returns 'pages'
- * withoutDirectoriesSuffix('pages_directories');
- * withoutDirectoriesSuffix('pages_versions_directories');
- */
-export declare const withoutDirectoriesSuffix: (slug: string) => CollectionSlug;
-/**
- * Add a _versions suffix to a given name.
- * Used for document versioning slug and tables.
- *
- * @example
- * // Returns 'pages_versions'
- * withVersionsSuffix('pages');
- */
-export declare const withVersionsSuffix: (name: string) => CollectionSlug;
-/**
- * Remove a _versions suffix from a given name.
- * Used for document versioning slug and tables.
- *
- * @example
- * // Returns 'pages'
- * withoutVersionsSuffix('pages_versions');
- */
-export declare const withoutVersionsSuffix: (name: string) => CollectionSlug;
-/**
- * Check if a slug is a verioned collection slug
- *  * @example
- * // Returns true
- * hasVersionsSuffix('pages_versions');
- *
- */
-export declare const hasVersionsSuffix: (slug: string) => boolean;
-/**
- * Check if a slug is a _directories collection slug
- *
- * @example
- * // Returns true
- * hasDirectoriesSuffix('medias_directories');
- */
-export declare const hasDirectoriesSuffix: (slug: string) => boolean;
-/**
- * Add a i18n suffix to a given name.
- * Used for localized tables name
- *
- * @example
- * // Returns 'pagesLocales'
- * withLocalesSuffix('pages');
- * // Returns 'pages_versionsLocales'
- * withLocalesSuffix('pages_versions');
- */
-export declare const withLocalesSuffix: (name: string) => string;
-/**
- * Convert a kebab-case prototype slug.
- * Basically used to convert param matchers slug into a collection/area slug.
- * Only a literal trailing `_directories`/`_versions` suffix is preserved as a
- * suffix — everything else, including a plain `-versions`/`-directories`
- * word, is camelCased like any other segment.
- *
- * @example
- * prototypeKebabToSlug('my-collection') // returns 'myCollection'
- * prototypeKebabToSlug('my-collection_directories') // returns 'myCollection_directories'
- * prototypeKebabToSlug('my-collection_versions') // returns 'myCollection_versions'
- * prototypeKebabToSlug('my-collection-versions') // returns 'myCollectionVersions'
- */
-export declare const prototypeKebabToSlug: (kebab: string) => string;