rimecms 0.22.0

package/dist/core/dev/generate/routes/collection.js

@@ -0,0 +1,129 @@
+import { PACKAGE_NAME } from '../../../constant.server.js';
+import { TScastVersionSlug } from './util.js';
+/**
+ * Layout server template for collection
+ * (rime)/panel/{collection.kebab}/+page.server.ts
+ */
+const pageServer = (slug) => `
+import { pagesLoad } from '${PACKAGE_NAME}/panel';
+export const load = pagesLoad.collection.list('${slug}')
+`;
+/**
+ * Page template for collection list
+ * (rime)/panel/{collection.kebab}/+page.svelte
+ */
+const page = (slug) => `
+<script>
+  import { Collection } from '${PACKAGE_NAME}/panel/client'
+  const { data } = $props()
+</script>
+<Collection {data} slug='${slug}' />`;
+/**
+ * Document page template
+ * (rime)/panel/{collection.kebab}/[id]/+page.svelte
+ */
+const docPage = () => `
+<script lang="ts">
+	import { CollectionDoc, type CollectionDocData } from '${PACKAGE_NAME}/panel/client';
+	const { data }: { data: CollectionDocData<false> } = $props();
+</script>
+
+<CollectionDoc {data} />`;
+/**
+ * Document page server template
+ * (rime)/panel/{collection.kebab}/[id]/+page.server.ts
+ * (rime)/panel/{collection.kebab}/[id]/versions/+page.server.ts
+ * Same actions / load for /versions page
+ * except the withVersion param
+ */
+const docPageServer = (slug) => `
+import { pagesLoad, pagesActions } from '${PACKAGE_NAME}/panel'
+
+export const load = pagesLoad.collection.doc('${slug}')
+export const actions = pagesActions.collection.doc('${slug}')`;
+const docPageServerVersions = (slug) => `
+import { pagesLoad, pagesActions } from '${PACKAGE_NAME}/panel'
+
+export const load = pagesLoad.collection.doc('${slug}', true)
+export const actions = pagesActions.collection.doc('${slug}')`;
+/**
+ * Document page versions template
+ * (rime)/panel/{collection.kebab}/[id]/versions/+page.svelte
+ */
+const docPageVersions = () => `
+<script lang="ts">
+	import { CollectionDocVersions, type CollectionDocData } from '${PACKAGE_NAME}/panel/client';
+	const { data }: { data: CollectionDocData<true> } = $props();
+</script>
+
+<CollectionDocVersions {data} />`;
+/**
+ * API collection list operations
+ * (rime)/api/{collection.kebab}/+server.ts
+ */
+const apiCollectionServer = (slug) => `
+import * as api from '${PACKAGE_NAME}/api';
+
+export const GET = api.collection.get(${TScastVersionSlug(slug)})
+export const POST = api.collection.create(${TScastVersionSlug(slug)})
+export const DELETE = api.collection.delete(${TScastVersionSlug(slug)})
+`;
+/**
+ * API collection document operations
+ * (rime)/api/{collection.kebab}/[id]/+server.ts
+ */
+const apiCollectionDocServer = (slug) => `
+import * as api from '${PACKAGE_NAME}/api';
+
+export const GET = api.collection.getById(${TScastVersionSlug(slug)})
+export const PATCH = api.collection.updateById(${TScastVersionSlug(slug)})
+export const DELETE = api.collection.deleteById(${TScastVersionSlug(slug)})
+`;
+/**
+ * API collection document duplication
+ * (rime)/api/{collection.kebab}/[id]/duplicate/+server.ts
+ */
+const apiCollectionDocDuplicateServer = (slug) => `
+import * as api from '${PACKAGE_NAME}/api';
+
+export const POST = api.collection.duplicate('${slug}')
+`;
+/****************************************************/
+/* Routes
+/****************************************************/
+/**
+ * Collection panel routes
+ */
+export const collectionPanelRoutes = {
+    '(rime)/panel/{collection.kebab}/': {
+        pageServer: pageServer,
+        page: page
+    },
+    '(rime)/panel/{collection.kebab}/[id]': {
+        page: docPage,
+        pageServer: docPageServer
+    }
+};
+/**
+ * Collection verions panel routes
+ */
+export const collectionVersionsPanelRoutes = {
+    '(rime)/panel/{collection.kebab}/[id]/versions': {
+        page: docPageVersions,
+        pageServer: docPageServerVersions
+    }
+};
+/**
+ * Collection API routes
+ */
+export const collectionAPIRoutes = {
+    '(rime)/api/{collection.kebab}/': {
+        server: apiCollectionServer
+    },
+    '(rime)/api/{collection.kebab}/[id]': {
+        server: apiCollectionDocServer
+    },
+    '(rime)/api/{collection.kebab}/[id]/duplicate': {
+        server: apiCollectionDocDuplicateServer
+    }
+};

package/dist/core/dev/generate/routes/common.d.ts

@@ -0,0 +1,8 @@
+import type { Routes } from './util.js';
+/**
+ * Custom route template generator
+ * Used for generating custom routes
+ */
+declare const customRoute: (config: any) => string;
+export declare const commonRoutes: Routes;
+export { customRoute };

package/dist/core/dev/generate/routes/common.js

@@ -0,0 +1,263 @@
+import { PACKAGE_NAME } from '../../../constant.server.js';
+import { OUTPUT_DIR } from '../../constants.js';
+// Trick to prevent svelte-kit to replace $lib with resolved imports path
+// same thing for PACKAGE_NAME
+const DOLLAR_LIB = '$lib';
+/**
+ * Main base layout
+ * /+layout.server.ts
+ */
+const mainLayout = () => `
+import type { ServerLoadEvent } from '@sveltejs/kit';
+export const load = async ({ locals, url }: ServerLoadEvent) => {
+	return { user: locals.user };
+};`;
+/**
+ * Error page template
+ * (rime)/+error.svelte
+ */
+const error = () => `
+<script>
+	import { page } from '$app/state';
+</script>
+
+<div class="container">
+	<h1>Error {page.status}</h1>
+	|
+	<p>
+		{page.error?.message}
+	</p>
+</div>`;
+/**
+ * Root layout template
+ * (rime)/+layout.svelte
+ */
+const rootLayout = () => `
+<script lang="ts">
+	import type { Snippet } from 'svelte';
+	import type { Dictionaries } from '${PACKAGE_NAME}/i18n';
+	import i18n from '${PACKAGE_NAME}/i18n';
+	import '${PACKAGE_NAME}/panel/style/index.css';
+
+	type Props = { children: Snippet; data: { translations: Dictionaries } };
+
+	const { children, data }: Props = $props();
+	i18n.init(data.translations);
+
+</script>
+
+<div class="rz-root">
+	{@render children()}
+</div>`;
+/**
+ * Root layout server template
+ * (rime)/+layout.server.ts
+ */
+const rootLayoutServer = () => `
+import type { ServerLoadEvent } from '@sveltejs/kit';
+import { registerTranslation } from '${PACKAGE_NAME}/i18n/register.server.js';
+
+export const ssr = false;
+
+export const load = async ({ locals }: ServerLoadEvent) => {
+	const { user, rime } = locals;
+	const translations = await registerTranslation(rime.config.raw.panel.language);
+	return { user, translations };
+};`;
+/**
+ * Login page template
+ * (rime)/panel/sign-in/+page.svelte
+ */
+const signInPage = () => `
+<script lang="ts">
+  import { SignIn } from '${PACKAGE_NAME}/panel/auth/client';
+  const { data } = $props();
+</script>
+
+<SignIn {data} />`;
+/**
+ * Login page server template
+ * (rime)/auth/sign-in/+page@(rime).server.ts
+ */
+const signInPageServer = () => `
+import { authLoads, authActions } from '${PACKAGE_NAME}/panel/auth';
+
+export const load = authLoads.signIn;
+export const actions = authActions.signIn;
+`;
+/**
+ * Forgot password page template
+ * (rime)/forgot-password/+page.svelte
+ */
+const forgotPasswordPage = () => `
+<script>
+  import { ForgotPassword } from '${PACKAGE_NAME}/panel/auth/client'
+  const { data } = $props();
+</script>
+<ForgotPassword {data} />`;
+/**
+ * Forgot password page server template
+ * (rime)/forgot-password/+page.server.ts
+ */
+const forgotPasswordPageServer = () => `
+import { authLoads } from '${PACKAGE_NAME}/panel/auth';
+
+export const load = authLoads.forgotPassword;
+`;
+/**
+ * Reset password page template
+ * (rime)/reset-password/+page.svelte
+ */
+const resetPasswordPage = () => `
+<script lang="ts">
+  import { ResetPassword } from '${PACKAGE_NAME}/panel/auth/client';
+  const { data } = $props();
+</script>
+
+<ResetPassword {data} />`;
+/**
+ * Reset password page server template
+ * (rime)/reset-password/+page.server.ts
+ */
+const resetPasswordPageServer = () => `
+import { authLoads } from '${PACKAGE_NAME}/panel/auth';
+
+export const load = authLoads.resetPassword;
+`;
+/**
+ * Panel layout template
+ * (rime)/panel/+layout.svelte
+ */
+const panelLayout = () => `
+<script>
+	import { Panel } from '${PACKAGE_NAME}/panel/client';
+
+	import config from '${DOLLAR_LIB}/${OUTPUT_DIR}/rime.config.js';
+	const { children, data } = $props();
+
+	const user = data.user;
+	if (!user) throw new Error('unauthorized');
+</script>
+
+<Panel {config} {user} routes={data.routes} locale={data.locale}>
+    {@render children()}
+</Panel>`;
+/**
+ * Panel layout server template
+ * (rime)/panel/+layout.server.ts
+ */
+const panelLayoutServer = () => `
+import { type ServerLoadEvent } from '@sveltejs/kit';
+
+export const load = async ({ locals }: ServerLoadEvent) => {
+  const { user, locale, routes } = locals;
+  return { user, locale, routes };
+};`;
+/**
+ * Panel page template
+ * (rime)/panel/+page.svelte
+ */
+const panelPage = () => `
+<script>
+  import { Dashboard } from '${PACKAGE_NAME}/panel/client';
+  const { data } = $props();
+</script>
+
+<Dashboard entries={data.entries} user={data.user} />`;
+/**
+ * Panel page load template
+ * (rime)/panel/+page.server.ts
+ */
+const panelPageServer = () => `
+import { pagesLoad } from '${PACKAGE_NAME}/panel';
+
+export const load = pagesLoad.dashboard;`;
+/**
+ * Live page template
+ * (rime)/live/+page.svelte
+ */
+const livePage = () => `
+<script lang="ts">
+  import { Live } from '${PACKAGE_NAME}/panel/client';
+
+  import config from '../../../lib/${OUTPUT_DIR}/rime.config.js';
+
+  const { data } = $props();
+</script>
+
+
+<Live {data} config={config} />`;
+/**
+ * Live page server template
+ * (rime)/live/+page.server.ts
+ */
+const livePageServer = () => `
+import { pagesLoad } from '${PACKAGE_NAME}/panel';
+
+export const load = pagesLoad.live;`;
+/**
+ * Custom route template generator
+ * Used for generating custom routes
+ */
+const customRoute = (config) => {
+    let componentPath = '';
+    let componentName = '';
+    const rawPath = typeof config.component === 'string'
+        ? config.component
+        : config.component[Symbol.for('filename')] || config.component[Symbol('filename')];
+    if (rawPath) {
+        const componentReg = /([A-Z][a-zA-Z0-9]+)\.svelte$/;
+        const match = rawPath.match(componentReg);
+        if (match) {
+            componentName = match[1];
+            if (rawPath.includes('node_modules/')) {
+                componentPath = 'node_modules/' + rawPath.split('node_modules/').at(-1);
+            }
+            else {
+                componentPath = '$lib/' + rawPath.split('lib/').at(-1);
+            }
+        }
+    }
+    if (componentName && componentPath) {
+        return `<script lang="ts">
+  import ${componentName} from '${componentPath}'
+  const { data } = $props()
+</script>
+<${componentName} {data} />`;
+    }
+    return `Cannot parse provided component path`;
+};
+// Shared routes dictionary
+export const commonRoutes = {
+    '': {
+        layoutServer: mainLayout
+    },
+    '(rime)': {
+        layout: rootLayout,
+        layoutServer: rootLayoutServer,
+        error: error
+    },
+    '(rime)/panel/sign-in': {
+        'page@(rime)': signInPage,
+        pageServer: signInPageServer
+    },
+    '(rime)/forgot-password': {
+        page: forgotPasswordPage,
+        pageServer: forgotPasswordPageServer
+    },
+    '(rime)/reset-password': {
+        page: resetPasswordPage,
+        pageServer: resetPasswordPageServer
+    },
+    '(rime)/panel': {
+        layout: panelLayout,
+        layoutServer: panelLayoutServer,
+        page: panelPage,
+        pageServer: panelPageServer
+    },
+    '(rime)/live': {
+        page: livePage,
+        pageServer: livePageServer
+    }
+};
+export { customRoute };

package/dist/core/dev/generate/routes/custom-css.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Injects a custom CSS link into the layout file
+ * @param layoutFilePath Path to the layout file
+ * @param cssPath Custom CSS path from config
+ * @example
+ * // Inject custom CSS into a layout file
+ * const layoutPath = '/path/to/src/routes/(rime)/+layout.svelte';
+ * const cssPath = '/assets/custom-styles.css';
+ * injectCustomCSS(layoutPath, cssPath);
+ * // This will add a <svelte:head> tag with a link to the CSS file
+ */
+export declare function injectCustomCSS(layoutFilePath: string, cssPath: string): void;
+/**
+ * Removes any custom CSS link from the layout file
+ * @param layoutFilePath Path to the layout file
+ * @example
+ * // Remove custom CSS from a layout file
+ * const layoutPath = '/path/to/src/routes/(rime)/+layout.svelte';
+ * removeCustomCSS(layoutPath);
+ * // This will remove any <svelte:head> tag and its contents from the layout file
+ */
+export declare function removeCustomCSS(layoutFilePath: string): void;

package/dist/core/dev/generate/routes/custom-css.js

@@ -0,0 +1,86 @@
+import { logger } from '../../../logger/index.server.js';
+import fs from 'fs';
+/**
+ * Injects a custom CSS link into the layout file
+ * @param layoutFilePath Path to the layout file
+ * @param cssPath Custom CSS path from config
+ * @example
+ * // Inject custom CSS into a layout file
+ * const layoutPath = '/path/to/src/routes/(rime)/+layout.svelte';
+ * const cssPath = '/assets/custom-styles.css';
+ * injectCustomCSS(layoutPath, cssPath);
+ * // This will add a <svelte:head> tag with a link to the CSS file
+ */
+export function injectCustomCSS(layoutFilePath, cssPath) {
+    try {
+        if (fs.existsSync(layoutFilePath)) {
+            const content = fs.readFileSync(layoutFilePath, 'utf8');
+            // Check if the file already has a svelte:head tag
+            if (content.includes('<svelte:head>')) {
+                // Check if the CSS link is already in the file
+                if (content.includes(cssPath)) {
+                    return; // CSS link already exists
+                }
+                // Replace the existing svelte:head tag with a new one that includes the CSS link
+                const headRegex = /(<svelte:head>)(.*?)(<\/svelte:head>)/s;
+                const cssLink = `\n  <link rel="stylesheet" href="${cssPath}" />\n  `;
+                const newContent = content.replace(headRegex, `$1$2${cssLink}$3`);
+                // Write the updated content back to the file
+                fs.writeFileSync(layoutFilePath, newContent, 'utf8');
+                logger.info(`Custom CSS link added in ${layoutFilePath}`);
+            }
+            else {
+                // No svelte:head tag, so insert one after the script tag
+                const scriptEndIndex = content.indexOf('</script>') + '</script>'.length;
+                if (scriptEndIndex > 0) {
+                    const beforeScript = content.substring(0, scriptEndIndex);
+                    const afterScript = content.substring(scriptEndIndex);
+                    const cssLink = `\n\n<svelte:head>\n  <link rel="stylesheet" href="${cssPath}" />\n</svelte:head>`;
+                    const newContent = beforeScript + cssLink + afterScript;
+                    // Write the updated content back to the file
+                    fs.writeFileSync(layoutFilePath, newContent, 'utf8');
+                    logger.info(`Custom CSS link added in ${layoutFilePath}`);
+                }
+                else {
+                    logger.error(`Could not find insertion point in ${layoutFilePath}`);
+                }
+            }
+        }
+        else {
+            logger.error(`Layout file not found: ${layoutFilePath}`);
+        }
+    }
+    catch (err) {
+        logger.error(`Error injecting custom CSS into layout file: ${err}`);
+    }
+}
+/**
+ * Removes any custom CSS link from the layout file
+ * @param layoutFilePath Path to the layout file
+ * @example
+ * // Remove custom CSS from a layout file
+ * const layoutPath = '/path/to/src/routes/(rime)/+layout.svelte';
+ * removeCustomCSS(layoutPath);
+ * // This will remove any <svelte:head> tag and its contents from the layout file
+ */
+export function removeCustomCSS(layoutFilePath) {
+    try {
+        if (fs.existsSync(layoutFilePath)) {
+            let content = fs.readFileSync(layoutFilePath, 'utf8');
+            if (content.includes('<svelte:head>')) {
+                // Remove the svelte:head tag and its contents
+                const headRegex = /<svelte:head>.*?<\/svelte:head>/s;
+                content = content.replace(headRegex, '');
+                // Write the updated content back to the file
+                fs.writeFileSync(layoutFilePath, content, 'utf8');
+                logger.info(`[✓] Custom CSS link removed from ${layoutFilePath}`);
+            }
+        }
+        else {
+            logger.error(`Layout file not found: ${layoutFilePath}`);
+        }
+    }
+    catch (err) {
+        logger.error(`Error removing custom CSS from layout file: ${err}`);
+    }
+}

package/dist/core/dev/generate/routes/index.d.ts

@@ -0,0 +1,6 @@
+import type { Config } from '../../../../types.js';
+/**
+ * Main function to generate browser routes based on configuration
+ */
+declare function generateRoutes<T extends Config>(config: T): void;
+export default generateRoutes;

package/dist/core/dev/generate/routes/index.js

@@ -0,0 +1,101 @@
+import { logger } from '../../../logger/index.server.js';
+import { withDirectoriesSuffix, withVersionsSuffix } from '../../../naming.js';
+import fs from 'fs';
+import path from 'path';
+import { areaAPIRoutes, areaRoutes, areaVersionsPanelRoutes } from './area.js';
+import { collectionAPIRoutes, collectionPanelRoutes, collectionVersionsPanelRoutes } from './collection.js';
+import { commonRoutes, customRoute } from './common.js';
+import { injectCustomCSS, removeCustomCSS } from './custom-css.js';
+import { ensureDir, shouldRegenerateRoutes, writeRouteFile } from './util.js';
+const projectRoot = process.cwd();
+/**
+ * Main function to generate browser routes based on configuration
+ */
+function generateRoutes(config) {
+    logger.info('Routes generation...');
+    const areas = (config.areas || []).filter((a) => a._generateRoutes !== false);
+    const collections = (config.collections || []).filter((c) => c._generateRoutes !== false);
+    // 1. Check if routes need to be regenerated
+    if (!shouldRegenerateRoutes(config)) {
+        return;
+    }
+    // 2. Ensure base directories exist
+    const rootRoutes = path.resolve(projectRoot, 'src', 'routes');
+    const rimeRoutes = path.join(rootRoutes, '(rime)');
+    const panelRoute = path.join(rimeRoutes, 'panel');
+    fs.rmSync(rimeRoutes, { recursive: true, force: true });
+    ensureDir(rootRoutes);
+    ensureDir(rimeRoutes);
+    ensureDir(panelRoute);
+    // Function that generate area/collection routes files from a Routes object
+    const processRoutes = (slug, kebab, routes) => {
+        for (const [pattern, files] of Object.entries(routes)) {
+            const routePath = pattern.replace('{area.kebab}', kebab).replace('{collection.kebab}', kebab);
+            // Generate each file type (page, layout, etc.)
+            for (const [fileType, templateFn] of Object.entries(files)) {
+                writeRouteFile(rootRoutes, routePath, fileType, templateFn(slug));
+            }
+        }
+    };
+    // 3. Process common routes
+    for (const [pattern, files] of Object.entries(commonRoutes)) {
+        for (const [fileType, templateFn] of Object.entries(files)) {
+            writeRouteFile(rootRoutes, pattern, fileType, templateFn());
+        }
+    }
+    // 4. Process area routes
+    for (const area of areas) {
+        processRoutes(area.slug, area.kebab, areaRoutes);
+        processRoutes(area.slug, area.kebab, areaAPIRoutes);
+        if (area.versions) {
+            processRoutes(area.slug, area.kebab, areaVersionsPanelRoutes);
+            // Use collections API route as area_versions is a collection
+            processRoutes(withVersionsSuffix(area.slug), withVersionsSuffix(area.kebab), collectionAPIRoutes);
+        }
+    }
+    // 5. Process collection routes
+    for (const collection of collections) {
+        // Function that generate routes files
+        const processRoutes = (slug, kebab, routes) => {
+            for (const [pattern, files] of Object.entries(routes)) {
+                const routePath = pattern.replace('{collection.kebab}', kebab);
+                // Generate each file type (page, layout, etc.)
+                for (const [fileType, templateFn] of Object.entries(files)) {
+                    // Check if function takes parameters before calling it
+                    const content = templateFn.length > 0 ? templateFn(slug) : templateFn();
+                    writeRouteFile(rootRoutes, routePath, fileType, content);
+                }
+            }
+        };
+        // Panel routes
+        processRoutes(collection.slug, collection.kebab, collectionPanelRoutes);
+        processRoutes(collection.slug, collection.kebab, collectionAPIRoutes);
+        if (collection.versions) {
+            processRoutes(collection.slug, collection.kebab, collectionVersionsPanelRoutes);
+            processRoutes(withVersionsSuffix(collection.slug), withVersionsSuffix(collection.kebab), collectionAPIRoutes);
+        }
+        if (collection.upload) {
+            processRoutes(withDirectoriesSuffix(collection.slug), withDirectoriesSuffix(collection.kebab), collectionAPIRoutes);
+        }
+    }
+    // 6. Handle custom routes from config
+    const customRoutes = config.panel?.routes;
+    if (customRoutes) {
+        for (const [route, routeConfig] of Object.entries(customRoutes)) {
+            const routePath = path.join('(rime)', 'panel', route);
+            writeRouteFile(rootRoutes, routePath, 'page', customRoute(routeConfig));
+        }
+    }
+    // 7. Handle custom CSS in layout file
+    const layoutPath = path.join(rimeRoutes, '+layout.svelte');
+    if (fs.existsSync(layoutPath)) {
+        if (config.panel?.css) {
+            injectCustomCSS(layoutPath, config.panel.css);
+        }
+        else {
+            removeCustomCSS(layoutPath);
+        }
+    }
+    logger.info('[✓] Routes generated');
+}
+export default generateRoutes;

package/dist/core/dev/generate/routes/util.d.ts

@@ -0,0 +1,52 @@
+import type { Config } from '../../../config/types.js';
+/**
+ * Types for route definitions
+ */
+export type RouteTemplateFunction<T extends any[] = any[]> = (...args: T) => string;
+export type RouteDefinition = Record<string, RouteTemplateFunction>;
+export type Routes = Record<string, RouteDefinition>;
+/**
+ * Check if routes need to be regenerated based on config changes
+ * @returns true if routes should be regenerated, false otherwise
+ * @example
+ * // Check if routes need to be regenerated
+ * const config = { areas: [], collections: [], panel: { css: 'styles.css' } };
+ * const needsRegeneration = shouldRegenerateRoutes(config);
+ * // If the config has changed since last run, needsRegeneration will be true
+ */
+export declare function shouldRegenerateRoutes<T extends Config>(config: T): boolean;
+/**
+ * Creates a directory if it doesn't exist
+ * @example
+ * // Ensure a directory exists
+ * const dirPath = '/path/to/directory';
+ * ensureDir(dirPath);
+ * // The directory will be created if it doesn't exist
+ */
+export declare function ensureDir(dirPath: string): void;
+/**
+ * Writes a route file with its content
+ * @param basePath The base path where routes are generated
+ * @param routePath The specific route path
+ * @param fileType The type of file to generate (page, pageServer, layout, layoutServer)
+ * @param content The content to write to the file
+ * @example
+ * // Write a page file for a collection
+ * const basePath = '/path/to/src/routes';
+ * const routePath = '(rime)/panel/news';
+ * const fileType = 'page';
+ * const content = '<script>\n  import { Collection } from "rime/panel"\n</script>...';
+ * writeRouteFile(basePath, routePath, fileType, content);
+ * // Creates /path/to/src/routes/(rime)/panel/news/+page.svelte with the provided content
+ */
+export declare function writeRouteFile(basePath: string, routePath: string, fileType: string, content: string): void;
+/**
+ * Cast slug in generated templates for document with versions
+ * in order to prevent TS error that slug_versions is not a collection/area
+ *
+ * @example
+ * castVersionSlug('pages_versions')
+ * // output : 'pages_versions' as any
+ * export const GET = api.collection.get('pages_versions' as any)
+ */
+export declare const TScastVersionSlug: (slug: string) => string;