rimecms 0.31.4 → 0.32.0

package/dist/core/config/types.d.ts

@@ -1,19 +1,39 @@
-import type { Adapter } from '../../adapter-sqlite/index.server.js';
-import type { PanelLanguage } from '../i18n/index.js';
-import type { Hook, HookBeforeOperation } from '../operations/hooks/index.server.js';
+import type { TableDeclaration, VersionsTable } from '../adapter.js';
+import type { LocalizationConfig } from '../locale/types.js';
+import type { PanelConfig, CollectionPanelConfig, CustomPanelRoute, NavigationConfig } from '../panel/types.js';
+import type { CacheConfig } from '../plugins/cache/types.js';
+import type { CollectionAuthConfig, AdditionalStaffConfig } from '../auth/types.js';
+import type { CollectionLabel } from '../prototype/collection/types.js';
+import type { UploadConfig } from '../prototype/collection/upload/types.js';
+import type { VersionsConfig } from '../prototype/shared/versions/types.js';
+import type { Adapter } from '../adapter.js';
+import type { Hook, HookBeforeOperation } from '../pipeline/types.js';
 import type { Plugin } from '../plugins/index.js';
-import type { SMTPConfig } from '../plugins/mailer/module.server.js';
-import type { Field, Option } from '../../fields/types.js';
+import type { SMTPConfig } from '../plugins/mailer/index.server.js';
+import type { Field } from '../../fields/types.js';
 import type { RegisterArea, RegisterCollection } from '../../index.js';
 import type { DashboardEntry } from '../../panel/pages/dashboard/types.js';
 import type { AreaSlug, CollectionSlug, User } from '../../types.js';
-import type { AtLeastOne, Dic, WithRequired } from '../../util/types.js';
+import type { Dic, WithRequired } from '../../util/types.js';
 import type { IconProps } from '@lucide/svelte';
 import type { RequestEvent, RequestHandler } from '@sveltejs/kit';
 import type { Component } from 'svelte';
 import type { FieldBuilder } from '../fields/builders/index.js';
-import type { BaseDoc, DocType } from '../types/doc.js';
+import type { DocType } from '../prototype/types.js';
+/**
+ * What an author writes.
+ *
+ * The two prototype lists were merged in from beside each definition, through a
+ * `PrototypeMembers` interface this extended. That kept core from naming a kind and made the
+ * authoring surface of every config in the repo depend on a declaration-merging target whose
+ * failure mode is silence: an augmentation that stops being reachable leaves the interface empty
+ * and `config.collections` starts reading `any`, far from the cause.
+ */
 export interface Config {
+    /** The collections an author writes. Optional here, defaulted to `[]` by the config chain. */
+    collections?: BuiltCollection[];
+    /** The areas an author writes. Same. */
+    areas?: BuiltArea[];
     /** If config.siteUrl is defined, a preview button is added
       on the panel dahsboard, pointing to this url  */
     siteUrl?: string;
@@ -32,10 +52,6 @@ export interface Config {
     $auth?: {
         plugins: any;
     };
-    /** List of Collection  */
-    collections?: BuiltCollection[];
-    /** List of Area  */
-    areas?: BuiltArea[];
     /** List of locales for document i18£n
      * @example
      * localization: {
@@ -97,78 +113,12 @@ export type Access = {
     update?: (user: User | undefined, options: AccessOptions) => boolean;
     delete?: (user: User | undefined, options: AccessOptions) => boolean;
 };
-export type AdditionalStaffConfig = {
-    roles?: (string | Option)[];
-    panel?: {
-        group?: string;
-    };
-    access?: Access;
-    label?: CollectionLabel;
-    fields?: FieldBuilder<Field>[];
-};
-export type PanelConfig = {
-    /** who can accesss the panel */
-    $access?: (user: User | undefined) => boolean;
-    /** Custom panel routes that render a given component */
-    routes?: Record<string, CustomPanelRoute>;
-    /** The panel language, "en" or "fr" supports only */
-    language?: PanelLanguage;
-    /** Sidebar navigation groups labels and icons */
-    navigation?: NavigationConfig;
-    /** Specific components */
-    components?: {
-        /** Dashboard header */
-        header?: Component[];
-        /** Collection header */
-        collectionHeader?: Component<{
-            config: BuiltCollectionClient;
-        }>[];
-        /** Full dashboard component */
-        dashboard?: Component<{
-            entries: DashboardEntry[];
-            user?: User;
-        }>;
-    };
-    /** a relative path from the "static" directory or an external url
-     * @example
-     * // for static/assets/custom.css
-     * css : '/assets/custom.css'
-     */
-    css?: string;
-};
-export type CacheConfig = {
-    isEnabled?: (event: RequestEvent) => boolean;
-};
 export type RouteConfig = {
     POST?: RequestHandler;
     GET?: RequestHandler;
     PATCH?: RequestHandler;
     DELETE?: RequestHandler;
 };
-export type LocalizationConfig = {
-    locales: LocaleConfig[];
-    default: string;
-};
-export type LocaleConfig = {
-    code: string;
-    label: string;
-};
-export type CollectionLabel = {
-    singular: string;
-    plural: string;
-    /** Label to search document, ex: Search for pages... */
-    search?: string;
-    /** Label for creation ex: New page */
-    create?: string;
-    /** Label when no document found, ex: No pages found */
-    none?: string;
-};
-export type VersionsConfig = {
-    draft?: boolean;
-    autoSave?: boolean;
-    maxVersions?: number;
-};
-export type UrlDefinition<T extends BaseDoc = BaseDoc> = (document: T) => string;
 type PrototypeConfig<S extends string = string> = {
     slug: S;
     /** Document fields definition */
@@ -181,62 +131,6 @@ type PrototypeConfig<S extends string = string> = {
     /** If the document can be edited live, if enabled the url prop must be set also. */
     live?: boolean;
 };
-export type UploadConfig = {
-    /**
-     * Define image sizes that will be generated when an image is uploaded.
-     * A 'thumbnail' size will be added, if none provided with this name.
-     * @example
-     * ```typescript
-     * imageSizes: [
-     *   {
-     *     name: 'thumbnail',
-     *     width: 200,
-     *     height: 200,
-     *     out: ['jpg', 'webp'],
-     *     compression: 80
-     *   },
-     *   {
-     *     name: 'medium',
-     *     width: 800,
-     *     compression: 85
-     *   }
-     * ]
-     * ```
-     */
-    imageSizes?: ImageSizesConfig[];
-    /**
-     * Allowed mimeTypes
-     * @example
-     * ```typescript
-     * accept: ['image/jpeg', 'image/svg']
-     * ```
-     */
-    accept?: string[];
-    /** Directories */
-    directories?: {
-        fields: FieldBuilder<Field>[];
-        access?: Access;
-        $hooks?: CollectionHooks<any>;
-    };
-};
-export type CollectionAuthConfig = ({
-    type: 'password';
-} | {
-    type: 'apiKey';
-}) & {
-    roles?: (string | Option)[];
-};
-export type CollectionPanelConfig = false | {
-    /** Description for the collection/area, basically displayed on the dashboard */
-    description?: string;
-    /** Sidebar navigation group */
-    group?: string;
-    /** Dashboard settings */
-    dashboard?: {
-        layout?: 'rows' | 'grid';
-        maxEntries?: number;
-    } | false;
-};
 export type Collection<S> = {
     slug: S;
     /** The collection label */
@@ -269,28 +163,6 @@ export type Area<S> = PrototypeConfig & {
         group?: string;
     };
 };
-type NavigationConfig = {
-    groups: Array<{
-        label: string;
-        icon: Component<IconProps>;
-    }>;
-};
-export type CustomPanelRoute = {
-    group?: string;
-    label: string;
-    icon?: Component<IconProps>;
-    component: Component;
-};
-export type ImageSizesConfig = {
-    name: string;
-    /** If none provided, will fallback to original file extesion */
-    out?: Array<'jpg' | 'webp'>;
-    /** Default compression: 60 */
-    compression?: number;
-} & AtLeastOne<{
-    width: number;
-    height: number;
-}>;
 export type BuiltCollection = Omit<Collection<string>, 'icon' | 'versions' | 'upload' | 'auth'> & {
     slug: CollectionSlug;
     type: 'collection';
@@ -303,12 +175,46 @@ export type BuiltCollection = Omit<Collection<string>, 'icon' | 'versions' | 'up
     asThumbnail: string | null;
     auth?: CollectionAuthConfig;
     versions?: Required<VersionsConfig>;
+    /**
+     * Where this config's content lives, when it is not its own row.
+     *
+     * Stamped by `augmentVersions` on a versioned config; `undefined` otherwise, which reads as
+     * "the document's own row". Declared here beside `versions` because it is the same statement,
+     * and because five callers read it — two of them in `adapter-sqlite/`, which is what keeps the
+     * adapter reading data rather than calling a feature.
+     */
+    _versions?: VersionsTable;
     upload?: UploadConfig;
     icon: Component<IconProps>;
     access: WithRequired<Access, 'create' | 'read' | 'update' | 'delete'>;
+    /**
+     * How the panel's dashboard should list this collection, when a feature has an opinion.
+     *
+     * Off the authoring surface — a config author writes `panel.dashboard.layout` — and the same
+     * device as `_titleFallback`: the feature that knows states its preference, and whoever renders
+     * reads it. `upload` sets `'grid'`, because a collection of files reads better as thumbnails.
+     * The dashboard's own default is `'rows'`, and what an author wrote beats both.
+     *
+     * It replaced `augment-panel.ts`, where the collection prototype tested `config.upload` to pick
+     * this — a prototype knowing what a feature is, and the whole reason this member exists.
+     */
+    _dashboardLayout?: 'rows' | 'grid';
     _generateTypes?: false;
     _generateSchema?: false;
     _generateRoutes?: false;
+    /**
+     * Whose content this config holds, in slug space — the inverse of `_versions`.
+     *
+     * ```
+     * pages              _shadowOf: undefined
+     * $pages__versions   _shadowOf: 'pages'
+     * ```
+     *
+     * Set by whichever feature derived the second table, so nothing has to read it off how the slug
+     * is spelled. `undefined` on every config an author wrote, which makes
+     * `config._shadowOf ?? config.slug` read as "the document this row belongs to".
+     */
+    _shadowOf?: string;
 };
 export type BuiltAreaClient = BuiltArea;
 export type BuiltArea = Omit<Area<string>, 'versions'> & {
@@ -321,6 +227,15 @@ export type BuiltArea = Omit<Area<string>, 'versions'> & {
     label: string;
     asTitle: string;
     versions?: Required<VersionsConfig>;
+    /**
+     * Where this config's content lives, when it is not its own row.
+     *
+     * Stamped by `augmentVersions` on a versioned config; `undefined` otherwise, which reads as
+     * "the document's own row". Declared here beside `versions` because it is the same statement,
+     * and because five callers read it — two of them in `adapter-sqlite/`, which is what keeps the
+     * adapter reading data rather than calling a feature.
+     */
+    _versions?: VersionsTable;
     icon: Component<IconProps>;
     access: WithRequired<Access, 'create' | 'read' | 'update' | 'delete'>;
     _generateTypes?: false;
@@ -328,23 +243,31 @@ export type BuiltArea = Omit<Area<string>, 'versions'> & {
     _generateRoutes?: false;
 };
 export type BuiltCollectionClient = BuiltCollection;
+/**
+ * What the config chain produced.
+ *
+ * The two lists with the optionality gone — which is what the chain guarantees by defaulting each
+ * to `[]`, so downstream reads `config.collections` without a guard.
+ */
 export type BuiltConfig = {
+    collections: BuiltCollection[];
+    areas: BuiltArea[];
     /** Database location relative to the root project ex: ./db/my-app.sqlite */
     $database: string;
     /** The database location */
     siteUrl?: string;
-    /** list of collections */
-    collections: BuiltCollection[];
-    /** list of areas */
-    areas: BuiltArea[];
     /** Define wich language the cms support */
     localization?: LocalizationConfig;
     icons: Record<string, any>;
     $trustedOrigins: string[];
+    /**
+     * Tables no prototype declares — better-auth's own, and whatever a plugin adds.
+     *
+     * Filled during the configure phase and appended to, so a consumer adding a better-auth plugin
+     * can declare that plugin's storage. The schema generator emits exactly what is here.
+     */
+    $tables: TableDeclaration[];
     $routes?: Record<string, RouteConfig>;
-    /** Fully-resolved plugin list, computed by augmentPluginsServer — internal, not the
-     * consumer-facing config key (that's just `plugins`) */
-    $plugins?: Plugin[];
     plugins?: Plugin[];
     panel: {
         routes: Record<string, CustomPanelRoute>;
@@ -371,14 +294,9 @@ export type BuiltConfig = {
     $custom?: Record<string, any>;
     custom?: Record<string, any>;
 };
-export type ServerConfigProps = '$adapter' | '$database' | '$trustedOrigins' | '$routes' | '$smtp' | '$custom' | '$auth';
-export type SanitizedConfigClient = Omit<Config, ServerConfigProps | 'collections' | 'areas'> & {
-    collections?: BuiltCollectionClient[];
-    areas?: BuiltAreaClient[];
-};
-export type BuiltConfigClient = Omit<BuiltConfig, ServerConfigProps | '$plugins' | 'panel' | 'collections' | 'areas'> & {
-    collections: BuiltCollectionClient[];
-    areas: BuiltAreaClient[];
+export type ServerConfigProps = '$adapter' | '$database' | '$trustedOrigins' | '$tables' | '$routes' | '$smtp' | '$custom' | '$auth';
+export type SanitizedConfigClient = Omit<Config, ServerConfigProps>;
+export type BuiltConfigClient = Omit<BuiltConfig, ServerConfigProps | 'panel'> & {
     icons: Dic<Component<IconProps>>;
     panel: {
         routes: Record<string, CustomPanelRoute>;

package/dist/core/config/validate.server.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from './types.js';
+declare function validate(config: Config): boolean;
+export default validate;

package/dist/core/config/validate.server.js

@@ -0,0 +1,259 @@
+import { validateAuth } from '../auth/validate-config.js';
+import { validateVersions } from '../prototype/shared/versions/validate-config.server.js';
+import cache from '../dev/cache.server.js';
+import { isFormField } from '../fields/util.js';
+import { logger } from '../logger.server.js';
+import { BlocksBuilder } from '../../fields/blocks/index.js';
+import { GroupFieldBuilder } from '../../fields/group/index.js';
+import { RelationFieldBuilder } from '../../fields/relation/index.js';
+import { TabsBuilder } from '../../fields/tabs/index.js';
+import { TreeBuilder } from '../../fields/tree/index.js';
+import { prototypeKebab } from '../prototype/naming.js';
+import { isCamelCase } from '../../util/string.js';
+function hasDuplicates(arr) {
+    return [...new Set(arr.filter((e, i, a) => a.indexOf(e) !== i))];
+}
+/**
+ * Check if there are multiple occurences
+ * of the same slug inside collections and areas
+ */
+function hasDuplicateSlug(config) {
+    const slugs = [];
+    for (const collection of config.collections || []) {
+        slugs.push(collection.slug);
+    }
+    for (const area of config.areas || []) {
+        slugs.push(area.slug);
+    }
+    const duplicates = hasDuplicates(slugs);
+    if (duplicates.length) {
+        return ['Duplicated collection/area slugs :' + duplicates.join(', ')];
+    }
+    return [];
+}
+/**
+ * Check that all area/collection slugs are camelCase
+ */
+function validateSlugs(config) {
+    const errors = [];
+    const slugs = [
+        ...(config.collections || []).map((c) => c.slug),
+        ...(config.areas || []).map((a) => a.slug)
+    ];
+    for (const slug of slugs) {
+        // `$` marks a slug rime derived itself ($pages__versions, $mediasDirectories), built from an
+        // author slug that was already validated. Skipped by the marker rather than by suffix, so core
+        // never has to know what a feature appends.
+        if (slug.startsWith('$'))
+            continue;
+        if (slug.includes('__')) {
+            errors.push(`Slug ${slug} may not contain "__": it marks a derived table (pages__versions), and a slug containing it would collide with one.`);
+            continue;
+        }
+        if (!isCamelCase(slug)) {
+            errors.push(`Slug ${slug} is not a valid prototype slug, it must be camelCase`);
+        }
+    }
+    return errors;
+}
+/**
+ * Prevent the panel user collection slug
+ * to be used elsewhere
+ */
+function hasUsersSlug(config) {
+    const invalid = (config.collections || []).filter((collection) => collection.slug === 'staff').length > 1;
+    if (invalid) {
+        return [`staff is a reserved slug for panel users`];
+    }
+    return [];
+}
+/**
+ * Validate documents fields for each collections
+ * and areas
+ */
+const validateFields = (config) => {
+    let errors = [];
+    for (const collection of config.collections || []) {
+        const collectionErrors = validateDocumentFields(collection, config);
+        errors = [...errors, ...collectionErrors];
+    }
+    for (const area of config.areas || []) {
+        const collectionErrors = validateDocumentFields(area, config);
+        errors = [...errors, ...collectionErrors];
+    }
+    return errors;
+};
+/**
+ *
+ */
+const validateDocumentFields = (documentConfig, config) => {
+    const errors = [];
+    const registeredBlocks = {};
+    const validateBlockField = (fields, blockType) => {
+        const reserved = ['path', 'type', 'ownerId', 'position', 'locale'];
+        for (const key of reserved) {
+            if (fields
+                .filter(isFormField)
+                .map((f) => f.name)
+                .filter((name) => name === key).length > 1) {
+                errors.push(`${key} is a reserved field in blocks (block ${blockType})`);
+            }
+        }
+    };
+    const validateRelationField = (field) => {
+        const collectionsSlugs = (config.collections || []).map((c) => c.slug);
+        if (!collectionsSlugs.includes(field.get.relationTo)) {
+            errors.push(`Relation field ${field.name} references unknown collection ${field.get.relationTo}, in ${documentConfig.type} ${documentConfig.slug}`);
+        }
+        // A relation is junction rows, and the base row has no junction. A reference that must sit
+        // there is a text column with `$references(slug, { resolve: true })`.
+        if (field.get.root) {
+            errors.push(`Relation field ${field.name} can't be $root(), in ${documentConfig.type} ${documentConfig.slug}`);
+        }
+    };
+    const validateFields = (fields) => {
+        // Check for field name duplication at this level
+        const duplicates = hasDuplicates(fields.filter(isFormField).map((f) => f.name));
+        if (duplicates.length) {
+            for (const duplicate of duplicates) {
+                errors.push(`Duplicate field '${duplicate}' in ${documentConfig.type} '${documentConfig.slug}'`);
+            }
+        }
+        function validateFieldName(name) {
+            // Regular expression to match
+            // __group_foo__truc, fooBlablaBla, _hello_guys
+            const pattern = /^(_+)?[a-zA-Z][a-zA-Z0-9_]*$/;
+            // Check if string matches pattern and doesn't contain spaces or hyphens
+            return pattern.test(name) && !name.includes('-') && !name.includes(' ');
+        }
+        function validateTabs(field) {
+            const duplicates = hasDuplicates(field.get.tabs.map((t) => t.name));
+            if (duplicates.length) {
+                errors.push(`Dupplicate tab name ${duplicates} in ${documentConfig.slug}`);
+            }
+        }
+        for (const field of fields) {
+            // Recursive check first into Tabs since tabs are not Formfields
+            if (field instanceof TabsBuilder) {
+                validateTabs(field);
+                for (const tab of field.get.tabs) {
+                    validateFields(tab.get.fields);
+                }
+            }
+            // If field is not a Formfield eg. Separator then continue
+            if (!isFormField(field)) {
+                continue;
+            }
+            // A `$root()` field sits on the base row, which has no locales branch.
+            if (field.get.root && field.get.localized) {
+                errors.push(`Field ${field.name} of ${documentConfig.type} ${documentConfig.slug} with $root(), can't be localized`);
+            }
+            // A resolved reference is joined from a column of the row; a localized column is on the
+            // locales branch, where no join reaches it.
+            if (field._references?.resolve && field.get.localized) {
+                errors.push(`Field ${field.name} of ${documentConfig.type} ${documentConfig.slug} with a resolved reference, can't be localized`);
+            }
+            // Check for malformed field.name
+            if (!validateFieldName(field.name)) {
+                errors.push(`Field ${field.name} of ${documentConfig.type} ${documentConfig.slug} should be camelCase`);
+            }
+            // Recursive check into Blocks
+            if (field instanceof BlocksBuilder) {
+                for (const block of field.get.blocks) {
+                    if (block.name in registeredBlocks) {
+                        const blockDefinedButDiffer = JSON.stringify(registeredBlocks[block.name]) !== JSON.stringify(block);
+                        if (blockDefinedButDiffer) {
+                            errors.push(`Each block with same name should be identique (block ${block.name})`);
+                        }
+                    }
+                    else {
+                        registeredBlocks[block.name] = block;
+                    }
+                    validateFields(block.get.fields.filter(isFormField));
+                    validateBlockField(block.get.fields.filter(isFormField), block.name);
+                }
+                // Recursive check into Tree
+            }
+            else if (field instanceof TreeBuilder) {
+                validateFields(field.get.fields.filter(isFormField));
+                // Recursive check into Tabs
+            }
+            else if (field instanceof GroupFieldBuilder) {
+                validateFields(field.get.fields.filter(isFormField));
+                // Check relation field
+            }
+            else if (field instanceof RelationFieldBuilder) {
+                validateRelationField(field);
+            }
+        }
+    };
+    validateFields(documentConfig.fields);
+    return errors;
+};
+const hasDatabase = (config) => {
+    const hasDatabaseName = '$adapter' in config;
+    if (!hasDatabaseName) {
+        return ['config.$adapter not defined'];
+    }
+    return [];
+};
+/**
+ * What each feature requires of a config that declares it. Every rule set guards its own
+ * not-declared case, so this only says which kinds of config each one is asked of.
+ *
+ * ```
+ * validateAuth       core/auth/validate-config.ts                        collections
+ * validateVersions   core/prototype/shared/versions/validate-config.server.ts   collections and areas
+ * ```
+ */
+function validateFeatures(config) {
+    const collections = config.collections || [];
+    const areas = config.areas || [];
+    return [
+        ...collections.flatMap((c) => validateAuth(c)),
+        ...[...collections, ...areas].flatMap((c) => validateVersions(c))
+    ];
+}
+/**
+ * Every prototype's `kebab` must actually be kebab.
+ *
+ * It is what the generated param matchers and every REST/panel URL are built from, so a slug
+ * leaking into it produces routes like `/api/$mediasDirectories` — and a 404, since the matcher
+ * and the link disagree with the config. That happened twice while the naming convention was
+ * being switched: both features that derive a prototype built its kebab from a *slug* helper
+ * instead of prototypeKebab. Neither is a type error, and neither shows up until a request is
+ * made, so it is checked here where codegen already runs.
+ */
+function validateKebabs(config) {
+    const errors = [];
+    const prototypes = [...(config.collections || []), ...(config.areas || [])];
+    for (const prototype of prototypes) {
+        const expected = prototypeKebab(prototype.slug);
+        if (prototype.kebab !== expected) {
+            errors.push(`Prototype ${prototype.slug} has kebab "${prototype.kebab}", expected "${expected}" — build it with prototypeKebab().`);
+        }
+    }
+    return errors;
+}
+function validate(config) {
+    const validateFunctions = [
+        hasDuplicateSlug,
+        validateSlugs,
+        validateKebabs,
+        hasUsersSlug,
+        validateFields,
+        validateFeatures,
+        hasDatabase
+    ];
+    for (const isValid of validateFunctions) {
+        const errors = isValid(config);
+        if (errors.length) {
+            cache.clear();
+            errors.map((err) => logger.error(err));
+            return false;
+        }
+    }
+    logger.debug('Config is valid');
+    return true;
+}
+export default validate;

package/dist/core/constants.d.ts

@@ -0,0 +1,69 @@
+export declare const PARAMS: {
+    /**
+     * The panel typing over a document: the update lands on the caller's own auto-saved row of the
+     * version `versionId` names, on a config with `versions: { draft: true, autoSave: true }`.
+     * Read by the panel form actions only; the REST API ignores it.
+     *
+     * @example ?/update&autoSave=true&versionId=abc
+     */
+    readonly AUTO_SAVE: "autoSave";
+    /** Fetch nested documents in relation / link at a specific depth */
+    readonly DEPTH: "depth";
+    /**
+     * Make a new version. The update starts from the row the other parameters select — the
+     * published one, the newest with `latest`, a named one with `versionId` — copies it into a new
+     * row, a draft unless the body says otherwise, and writes the body onto that row. Without it an
+     * update writes the selected row in place.
+     *
+     * A config with versions and no drafts keeps a version per save: there, an update that names
+     * no `versionId` is a fork whether it says so or not. Every case is tabled on
+     * `defineVersionUpdateOperation` in `core/prototype/shared/versions/strategy.ts`.
+     *
+     * @example PATCH /api/pages/<id>?fork=true
+     */
+    readonly FORK: "fork";
+    /**
+     * The newest version, whatever its status, where the published one is meant otherwise. The
+     * same on a read and on a write: `GET ?latest=true` returns it, `PATCH ?latest=true` writes
+     * it. `versionId` names a row and makes this moot. Only a config with drafts has a published
+     * row to prefer, and only staff may ask; anyone else gets the published version.
+     *
+     * @example GET /api/pages/<id>?latest=true
+     */
+    readonly LATEST: "latest";
+    /**
+     * GET operations limit number of documents
+     * @example ?limit=4
+     */
+    readonly LIMIT: "limit";
+    /** GET / CREATE / UPDATE a specific document locale
+     * @example ?locale=en
+     */
+    readonly LOCALE: "locale";
+    /** GET documents with an offset number
+     * @example ?limit=4&offset=4
+     */
+    readonly OFFSET: "offset";
+    /**
+     * Redirect or not after creation operation
+     * @example ?redirect=false
+     */
+    readonly REDIRECT: "redirect";
+    /** On fetch operation fields to be fetched
+     * @example ?depth=3
+     */
+    readonly SELECT: "select";
+    /** On fetch list operation order documents
+     * @example ?sort=-title
+     */
+    readonly SORT: "sort";
+    /** GET / UPDATE a specific version*/
+    readonly VERSION_ID: "versionId";
+    /** On fetch (upload) list operation filter out documents from a specific uploadPath */
+    readonly UPLOAD_PATH: "uploadPath";
+    /**
+     * Disable validation on CREATE / UPDATE operations
+     * @example ?skipValidation=true
+     */
+    readonly SKIP_VALIDATION: "skipValidation";
+};