rimecms 0.22.0

package/dist/core/dev/cli/clear/index.js

@@ -0,0 +1,37 @@
+import { logger } from '../../../logger/index.server.js';
+import { rmSync } from 'node:fs';
+import path from 'node:path';
+import { INPUT_DIR, OUTPUT_DIR } from '../../constants.js';
+import { prompt } from '../util.server.js';
+const clearMessage = `Are you sure you want to delete all related rime files (Y/n):
+- ./static/medias
+- ./db
+- ./src/routes/(rime)
+- ./src/lib/${INPUT_DIR}
+- ./src/lib/${OUTPUT_DIR}
+- ./src/app.generated.d.ts
+- ./src/hooks.server.ts
+- ./drizzle.config.ts
+`;
+export const clear = async (args) => {
+    let shouldProceed = true;
+    if (!args.force) {
+        const response = await prompt(`${clearMessage} (Y/n)`, 'n');
+        shouldProceed = response.trim().toLowerCase() === 'y';
+    }
+    if (!shouldProceed) {
+        return logger.info('Operation cancelled. Great!');
+    }
+    // Remove directories
+    rmSync(path.join('.rime'), { recursive: true, force: true });
+    rmSync(path.join('src', 'routes', '(rime)'), { recursive: true, force: true });
+    rmSync(path.join('src', 'lib', INPUT_DIR), { recursive: true, force: true });
+    rmSync(path.join('src', 'lib', OUTPUT_DIR), { recursive: true, force: true });
+    rmSync(path.join('db'), { recursive: true, force: true });
+    rmSync(path.join('static', 'medias'), { recursive: true, force: true });
+    // Remove files
+    rmSync(path.join('src', 'hooks.server.ts'), { force: true });
+    rmSync(path.join('src', 'app.generated.d.ts'), { force: true });
+    rmSync(path.join('drizzle.config.ts'), { force: true });
+    return logger.info('rime cleared');
+};

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

@@ -0,0 +1,3 @@
+export declare const generate: (args: {
+    force?: boolean;
+}) => Promise<void>;

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

@@ -0,0 +1,79 @@
+import cache from '../../cache/index.js';
+import { sanitize } from '../../generate/sanitize/index.js';
+import { ensureGeneratedConfig, ensureUserConfigExist } from '../../../ensure.server.js';
+import { logger } from '../../../logger/index.server.js';
+import { trycatch } from '../../../../util/function.js';
+import { mkdirSync, rmSync } from 'fs';
+import path from 'path';
+export const generate = async (args) => {
+    const { force } = args;
+    /**
+     * Clear the cached .rime folder
+     */
+    function clearConfigCache() {
+        try {
+            rmSync(path.join(process.cwd(), '.rime'), { recursive: true, force: true });
+            mkdirSync(path.join(process.cwd(), '.rime'));
+        }
+        catch (err) {
+            logger.error(err.message);
+        }
+    }
+    /*
+     * Delete routes/(rime) folder
+     */
+    function clearRoutes() {
+        try {
+            rmSync(path.join(process.cwd(), 'src', 'routes', '(rime)'), { recursive: true, force: true });
+        }
+        catch (err) {
+            logger.error(err.message);
+        }
+    }
+    /**
+     * Sanitize the user config and create the config.generated folder
+     */
+    async function sanitizeConfig() {
+        await sanitize();
+    }
+    /**
+     * Create the vite devServer
+     */
+    async function createServer() {
+        const { createServer } = await import('vite');
+        // Create a Vite server using the project's vite.config.ts
+        const vite = await createServer({
+            configFile: path.join(process.cwd(), 'vite.config.ts'),
+            server: {
+                hmr: false,
+                middlewareMode: true
+            },
+            optimizeDeps: { disabled: true },
+            appType: 'custom',
+            logLevel: 'error'
+        });
+        return vite;
+    }
+    async function run() {
+        if (force) {
+            clearConfigCache();
+            clearRoutes();
+        }
+        ensureUserConfigExist();
+        await sanitizeConfig();
+        const importPathJS = ensureGeneratedConfig();
+        logger.info('Generate');
+        const vite = await createServer();
+        await vite.ssrLoadModule(importPathJS);
+        while (cache.get('.init')) {
+            await new Promise((resolve) => setTimeout(resolve, 200));
+        }
+        await vite.close();
+        logger.info('[✓] Generation completed successfully');
+    }
+    const [error] = await trycatch(run);
+    if (error) {
+        logger.error('Error during generation:', error);
+        throw error;
+    }
+};

package/dist/core/dev/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/core/dev/cli/index.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+program.version('0.1').description('CMS utilities');
+program.description('Rime utilities');
+program
+    .command('init')
+    .option('-n, --name <name>', 'Will be the database name')
+    .option('-f, --force', 'Force init with default package name', false)
+    .option('-s, --skip-install', 'Do not install dependencies', false)
+    .action(async (args) => {
+    const init = await import('./init/index.js').then((m) => m.init);
+    init(args);
+});
+program
+    .command('build')
+    .option('-d, --with-database', 'Include database', false)
+    .option('-f, --force', 'Force init with default package name', false)
+    .action(async (args) => {
+    const build = await import('./build/index.js').then((m) => m.build);
+    build(args);
+});
+program
+    .command('clear')
+    .option('-f, --force', 'Force clear without prompt', false)
+    .action(async (args) => {
+    const clear = await import('./clear/index.js').then((m) => m.clear);
+    clear(args);
+});
+program
+    .command('generate')
+    .option('-f, --force', 'Force generation, ignore cache, overwrite routes', false)
+    .action(async (args) => {
+    const generate = await import('./generate/index.js').then((m) => m.generate);
+    generate({
+        force: args.force
+    });
+});
+program.parse(process.argv);

package/dist/core/dev/cli/init/getPackageName.d.ts

@@ -0,0 +1 @@
+export declare function getPackageInfoByKey(key: string): string;

package/dist/core/dev/cli/init/getPackageName.js

@@ -0,0 +1,17 @@
+import path from 'path';
+import fs from 'fs';
+export function getPackageInfoByKey(key) {
+    try {
+        // Read the package.json file
+        const packageJsonPath = path.join(process.cwd(), 'package.json');
+        const packageJsonContent = fs.readFileSync(packageJsonPath, 'utf-8');
+        // Parse the JSON content
+        const packageJson = JSON.parse(packageJsonContent);
+        // Return the name
+        return packageJson[key] || '';
+    }
+    catch (error) {
+        console.error('Error reading package.json:', error);
+        return '';
+    }
+}

package/dist/core/dev/cli/init/index.d.ts

@@ -0,0 +1,7 @@
+type Args = {
+    force?: boolean;
+    skipInstall?: boolean;
+    name?: string;
+};
+export declare const init: ({ force, name: incomingName, skipInstall }: Args) => Promise<void>;
+export {};

package/dist/core/dev/cli/init/index.js

@@ -0,0 +1,204 @@
+import { logger } from '../../../logger/index.server.js';
+import { randomId } from '../../../../util/random.js';
+import { isValidSlug, slugify } from '../../../../util/string.js';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { cp, mkdir } from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { INPUT_DIR } from '../../constants.js';
+import { generate } from '../generate/index.js';
+import { prompt } from '../util.server.js';
+import { getPackageInfoByKey } from './getPackageName.js';
+import { installDependencies } from './packageManagerUtil.js';
+import * as templates from './templates.js';
+const PACKAGE = 'rimecms';
+const root = process.cwd();
+export const init = async ({ force, name: incomingName, skipInstall }) => {
+    const packageName = getPackageInfoByKey('name');
+    function setEnv() {
+        const envPath = path.resolve(root, '.env');
+        // Define variables with their update behavior
+        const envUpdates = {
+            BETTER_AUTH_SECRET: randomId(32),
+            PUBLIC_RIME_URL: 'http://localhost:5173',
+            '# RIME_SMTP_USER': 'user@mail.com',
+            '# RIME_SMTP_PASSWORD': 'supersecret',
+            '# RIME_SMTP_PORT': '465',
+            '# RIME_SMTP_HOST': 'smtphost.com',
+            RIME_LOG_LEVEL: 'TRACE',
+            RIME_LOG_TO_FILE: 'true',
+            RIME_LOG_TO_FILE_MAX_DAYS: '1'
+        };
+        if (existsSync(envPath)) {
+            logger.info('[✓] .env file found');
+            let envContent = readFileSync(envPath, 'utf-8');
+            Object.entries(envUpdates).forEach(([key, value]) => {
+                const exists = envContent.match(new RegExp(`^${key}=`, 'm'));
+                if (!exists) {
+                    // Add new value if doesn't exist
+                    envContent += `\n${key}=${value}`;
+                    logger.info(`- ${key} added`);
+                }
+            });
+            writeFileSync(envPath, envContent);
+            logger.info('[✓] .env file populated');
+        }
+        else {
+            writeFileSync(envPath, templates.env());
+            logger.info('[✓] .env file created');
+        }
+    }
+    function setConfig(name) {
+        const configDirPath = path.resolve(root, 'src/lib', INPUT_DIR);
+        const configPath = path.join(configDirPath, 'rime.config.ts');
+        if (!existsSync(configPath)) {
+            if (!existsSync(configDirPath)) {
+                mkdirSync(configDirPath);
+            }
+            writeFileSync(configPath, templates.defaultConfig(name.toString()));
+            logger.info('[✓] Config created src/lib/config/rime.config.ts');
+        }
+        else {
+            logger.info('[✓] Config already exists (skip)');
+        }
+    }
+    function setDatabase() {
+        const dbPath = path.join(root, 'db');
+        if (!existsSync(dbPath)) {
+            mkdirSync(dbPath);
+            logger.info('[✓] Database folder created');
+        }
+        else {
+            logger.info('[✓] Database folder already exists (skip)');
+        }
+    }
+    function addToGitignore() {
+        const gitignorePath = path.join(root, '.gitignore');
+        if (!existsSync(gitignorePath)) {
+            logger.warn('.gitignore not found (skip)');
+            return;
+        }
+        let gitignoreContent = readFileSync(gitignorePath, 'utf-8');
+        const updates = ['\\.rime', '\\.cache', '/logs', '/db', '\\+rime.generated'];
+        if (!gitignoreContent.includes('# rime'))
+            gitignoreContent += '\n# rime';
+        for (const line of updates) {
+            const exists = gitignoreContent.match(new RegExp(`^${line}`, 'm'));
+            if (!exists) {
+                // Add new value if doesn't exist
+                gitignoreContent += `\n${line.replace('\\', '')}`;
+            }
+        }
+        writeFileSync(gitignorePath, gitignoreContent);
+        logger.info('[✓] .gitignore populated');
+    }
+    function setDrizzle(name) {
+        const drizzleConfigPath = path.join(root, 'drizzle.config.ts');
+        if (!existsSync(drizzleConfigPath)) {
+            writeFileSync(drizzleConfigPath, templates.drizzleConfig(name.toString()));
+            logger.info('[✓] Drizzle config added');
+        }
+        else {
+            logger.info('[✓] Drizzle config already exists (skip)');
+        }
+    }
+    function configureVite() {
+        const configPath = path.resolve(root, 'vite.config.ts');
+        if (!existsSync(configPath)) {
+            throw new Error("Can't find vite configuration file");
+        }
+        const content = readFileSync(configPath, 'utf-8');
+        if (!content.includes('rime()')) {
+            // Add import
+            const newContent = content.replace(/(import .* from .*;\n?)/, `$1import { rime } from '${PACKAGE}/vite';\n`);
+            // Add plugin to the list - ensure it's after sveltekit()
+            const updatedContent = newContent.replace(/plugins:\s*\[([\s\S]*?)\]/, (match, plugins) => {
+                // Check if sveltekit() is in the plugins list
+                if (plugins.includes('sveltekit()')) {
+                    // Add rime() after sveltekit()
+                    return plugins.includes('sveltekit()')
+                        ? match.replace('sveltekit()', 'sveltekit(), rime()')
+                        : `plugins: [${plugins}, rime()]`;
+                }
+                else {
+                    // If sveltekit() isn't found, add rime() at the end
+                    return `plugins: [${plugins}, rime()]`;
+                }
+            });
+            writeFileSync(configPath, updatedContent);
+            logger.info('[✓] Vite plugin added');
+        }
+        else {
+            logger.info('[✓] Vite plugin already present (skip)');
+        }
+    }
+    function setHooks() {
+        const hooksPath = path.join(root, 'src', 'hooks.server.ts');
+        const srcDir = path.join(root, 'src');
+        // Check if file exists
+        if (!existsSync(hooksPath)) {
+            // Ensure src directory exists
+            if (!existsSync(srcDir)) {
+                mkdirSync(srcDir, { recursive: true });
+            }
+            // Create hooks.server.ts with template content
+            writeFileSync(hooksPath, templates.hooks, 'utf-8');
+            logger.info('[✓] hooks.server.ts created');
+        }
+        else {
+            logger.info('[✓] hooks.server.ts already exists (skip)');
+        }
+    }
+    async function copyAssets() {
+        try {
+            const currentDir = path.dirname(fileURLToPath(import.meta.url));
+            await mkdir(path.resolve(process.cwd(), 'static/panel/fonts'), { recursive: true });
+            await cp(path.join(currentDir, '../../../../panel/fonts'), path.resolve(process.cwd(), 'static/panel/fonts'), {
+                recursive: true
+            });
+            logger.info('[✓] Copied assets');
+        }
+        catch (err) {
+            console.error('Error copying fonts:', err);
+        }
+    }
+    if (force || incomingName) {
+        const name = incomingName || packageName;
+        setEnv();
+        addToGitignore();
+        setConfig(name);
+        setDatabase();
+        setDrizzle(name);
+        setHooks();
+        configureVite();
+        await copyAssets();
+        !skipInstall && installDependencies();
+        await generate({ force: true });
+    }
+    else {
+        let name = '';
+        const defaultName = slugify(packageName);
+        let tries = 0;
+        while (!isValidSlug(name)) {
+            name = await prompt(tries > 0
+                ? 'Error: should contains only letters, numbers, hyphens, underscores\nWhat is your project name (will be used as database name) ?'
+                : 'What is your project name (will be used as database name) ?', defaultName || 'app');
+            tries++;
+        }
+        if (!name) {
+            logger.error('Operation cancelled');
+            process.exit(0);
+        }
+        setEnv();
+        addToGitignore();
+        setConfig(name);
+        setDatabase();
+        setDrizzle(name);
+        setHooks();
+        configureVite();
+        await copyAssets();
+        !skipInstall && installDependencies();
+        await generate({ force: true });
+        logger.info('[✓] done');
+    }
+};

package/dist/core/dev/cli/init/packageManagerUtil.d.ts

@@ -0,0 +1,3 @@
+export type PackageManagerName = 'yarn' | 'pnpm' | 'bun' | 'npm' | 'deno';
+export declare function getPackageManager(): PackageManagerName;
+export declare function installDependencies(): void;

package/dist/core/dev/cli/init/packageManagerUtil.js

@@ -0,0 +1,80 @@
+import { logger } from '../../../logger/index.server.js';
+import { execSync } from 'child_process';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import path from 'path';
+const packageManagersMap = {
+    yarn: 'yarn.lock',
+    pnpm: 'pnpm-lock.yaml',
+    bun: 'bun.lock',
+    npm: 'package-lock.json',
+    deno: 'deno.lock'
+};
+const packageManagerConfigs = {
+    yarn: {
+        command: 'yarn add -D drizzle-kit'
+    },
+    pnpm: {
+        command: 'pnpm add -D drizzle-kit && pnpm add drizzle-orm @lucide/svelte sharp',
+        preInstall: updatePackageJsonForPnpm,
+        postInstall: () => {
+            execSync('pnpm rebuild');
+        }
+    },
+    bun: {
+        command: 'bun add -D drizzle-kit'
+    },
+    npm: {
+        command: 'npm install -D drizzle-kit'
+    },
+    deno: {
+        command: 'deno install -D npm:drizzle-kit && deno install --allow-scripts=npm:sharp'
+    }
+};
+export function getPackageManager() {
+    for (const [packageManager, lockFile] of Object.entries(packageManagersMap)) {
+        const pathToLockFile = path.resolve(process.cwd(), lockFile);
+        if (existsSync(pathToLockFile)) {
+            return packageManager;
+        }
+    }
+    return 'npm';
+}
+export function installDependencies() {
+    const pm = getPackageManager();
+    if (pm === 'deno' || pm === 'yarn') {
+        throw new Error('Unsupported package manager ' + pm);
+    }
+    const config = packageManagerConfigs[pm];
+    // Pre installation hooks
+    config.preInstall?.();
+    // Main installation
+    logger.info('exec : ' + config.command);
+    execSync(config.command);
+    // Post installation hooks
+    config.postInstall?.();
+}
+function updatePackageJsonForPnpm() {
+    const packageJsonPath = path.resolve(process.cwd(), 'package.json');
+    if (!existsSync(packageJsonPath)) {
+        logger.warn('package.json not found, skipping pnpm configuration');
+        return;
+    }
+    try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+        // Initialize pnpm configuration if it doesn't exist
+        if (!packageJson.pnpm) {
+            packageJson.pnpm = {};
+        }
+        // Update onlyBuiltDependencies
+        const existingBuiltDeps = packageJson.pnpm.onlyBuiltDependencies || [];
+        const newBuiltDeps = ['esbuild', 'sharp'];
+        // Merge and deduplicate
+        const mergedBuiltDeps = [...new Set([...existingBuiltDeps, ...newBuiltDeps])];
+        packageJson.pnpm.onlyBuiltDependencies = mergedBuiltDeps;
+        writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, '\t'), 'utf-8');
+        logger.info('[✓] Updated package.json with pnpm configuration');
+    }
+    catch (error) {
+        logger.error('Failed to update package.json for pnpm:', error);
+    }
+}

package/dist/core/dev/cli/init/templates.d.ts

@@ -0,0 +1,4 @@
+export declare const env: () => string;
+export declare const defaultConfig: (name: string) => string;
+export declare const drizzleConfig: (name: string) => string;
+export declare const hooks = "import { sequence } from '@sveltejs/kit/hooks';\nimport { handlers } from 'rimecms';\nimport config from './lib/+rime.generated/rime.config.server.js';\n\nexport const handle = sequence(...(await handlers(config)));\n";

package/dist/core/dev/cli/init/templates.js

@@ -0,0 +1,52 @@
+import { randomId } from '../../../../util/random.js';
+import { OUTPUT_DIR } from '../../constants.js';
+const PACKAGE = 'rimecms';
+export const env = () => `BETTER_AUTH_SECRET=${randomId(32)}
+PUBLIC_RIME_URL=http://localhost:5173
+
+# RIME_CACHE_ENABLED=false
+# RIME_SMTP_USER=user@mail.com
+# RIME_SMTP_PASSWORD=supersecret
+# RIME_SMTP_HOST=smtphost.com
+# RIME_SMTP_PORT=465
+
+RIME_CACHE_ENABLED=false
+RIME_LOG_LEVEL=TRACE
+RIME_LOG_TO_FILE=true
+RIME_LOG_TO_FILE_MAX_DAYS=1
+`;
+export const defaultConfig = (name) => `
+import { Collection, rime } from '$rime/config';
+import { text } from '${PACKAGE}/fields';
+import { adapterSqlite } from '${PACKAGE}/sqlite';
+
+const Pages = Collection.create('pages', {
+	fields: [text('title').isTitle()]
+});
+
+export default rime({
+  $adapter: adapterSqlite('${name}.sqlite'),
+  collections: [Pages]
+});
+`;
+export const drizzleConfig = (name) => `
+import { defineConfig, type Config } from 'drizzle-kit';
+
+export const config: Config = {
+  schema: './src/lib/${OUTPUT_DIR}/schema.server.ts',
+  out: './db',
+  strict: false,
+  dialect: 'sqlite',
+  dbCredentials: {
+    url: './db/${name}.sqlite'
+  }
+};
+
+export default defineConfig(config);
+`;
+export const hooks = `import { sequence } from '@sveltejs/kit/hooks';
+import { handlers } from '${PACKAGE}';
+import config from './lib/${OUTPUT_DIR}/rime.config.server.js';
+
+export const handle = sequence(...(await handlers(config)));
+`;

package/dist/core/dev/cli/util.server.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Simple function to ask a question and get user input
+ */
+export declare function prompt(query: string, defaultValue: string): Promise<string>;

package/dist/core/dev/cli/util.server.js

@@ -0,0 +1,16 @@
+import readline from 'node:readline';
+/**
+ * Simple function to ask a question and get user input
+ */
+export function prompt(query, defaultValue) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve) => {
+        rl.question(`${query} (default: ${defaultValue}): `, (answer) => {
+            rl.close();
+            resolve(answer || defaultValue);
+        });
+    });
+}

package/dist/core/dev/constants.d.ts

@@ -0,0 +1,2 @@
+export const OUTPUT_DIR: "+rime.generated";
+export const INPUT_DIR: "+rime";

package/dist/core/dev/constants.js

@@ -0,0 +1,2 @@
+export const OUTPUT_DIR = '+rime.generated';
+export const INPUT_DIR = '+rime';

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

@@ -0,0 +1,7 @@
+import { type Routes } from './util.js';
+/**
+ * Area routes dictionary defining route patterns and their corresponding templates
+ */
+export declare const areaRoutes: Routes;
+export declare const areaVersionsPanelRoutes: Routes;
+export declare const areaAPIRoutes: Routes;

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

@@ -0,0 +1,69 @@
+import { PACKAGE_NAME } from '../../../constant.server.js';
+import { TScastVersionSlug } from './util.js';
+/**
+ * Area templates defined outside of the routes object
+ * (rime)/panel/{area.kebab}/+page.svelte
+ */
+const pageTemplate = () => `
+<script>
+  import { Area } from '${PACKAGE_NAME}/panel/client'
+  const { data } = $props()
+</script>
+<Area {data} />`;
+/**
+ * Page server template for area
+ * (rime)/panel/{area.kebab}/+page.server.ts
+ */
+const pageServerTemplate = (slug) => `
+import { pagesLoad, pagesActions } from '${PACKAGE_NAME}/panel'
+
+export const load = pagesLoad.area('${slug}')
+export const actions = pagesActions.area('${slug}')
+`;
+const pageServerTemplateVersions = (slug) => `
+import { pagesLoad, pagesActions } from '${PACKAGE_NAME}/panel'
+
+export const load = pagesLoad.area('${slug}', true)
+export const actions = pagesActions.area('${slug}')
+`;
+/**
+ * API collection list operations
+ * (rime)/api/{collection.slug}/+server.ts
+ */
+const apiAreaServer = (slug) => `
+import * as api from '${PACKAGE_NAME}/api';
+
+export const GET = api.area.get(${TScastVersionSlug(slug)})
+export const PATCH = api.area.update(${TScastVersionSlug(slug)})
+`;
+/**
+ * Document page versions template
+ * (rime)/panel/{collection.slug}/[id]/versions/+page.svelte
+ */
+const pageVersions = () => `
+<script lang="ts">
+	import { AreaVersionsDoc, type AreaDocData } from '${PACKAGE_NAME}/panel/client';
+	const { data }: { data: AreaDocData<true> } = $props();
+</script>
+
+<AreaVersionsDoc {data} />`;
+/**
+ * Area routes dictionary defining route patterns and their corresponding templates
+ */
+export const areaRoutes = {
+    '(rime)/panel/{area.kebab}/': {
+        page: pageTemplate,
+        pageServer: pageServerTemplate
+    }
+};
+export const areaVersionsPanelRoutes = {
+    '(rime)/panel/{area.kebab}/versions': {
+        page: pageVersions,
+        pageServer: pageServerTemplateVersions
+    }
+};
+export const areaAPIRoutes = {
+    '(rime)/api/{area.kebab}/': {
+        server: apiAreaServer
+    }
+};

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

@@ -0,0 +1,14 @@
+import { type Routes } from './util.js';
+/****************************************************/
+/**
+ * Collection panel routes
+ */
+export declare const collectionPanelRoutes: Routes;
+/**
+ * Collection verions panel routes
+ */
+export declare const collectionVersionsPanelRoutes: Routes;
+/**
+ * Collection API routes
+ */
+export declare const collectionAPIRoutes: Routes;