rimecms 0.22.0

package/dist/adapter-sqlite/with.js

@@ -0,0 +1,270 @@
+import { getFieldConfigByPath } from '../core/fields/util.js';
+import { withLocalesSuffix } from '../core/naming.js';
+import { isBlocksFieldRaw } from '../fields/blocks/index.js';
+import { isRelationField } from '../fields/relation/index.js';
+import { isTreeFieldRaw } from '../fields/tree/index.js';
+import { asc, eq, getTableColumns, SQL } from 'drizzle-orm';
+import { getBlocksTableNames, getTreeTableNames } from './generate-schema/util.js';
+export const buildWithParam = (args) => {
+    const { slug, select = [], locale, tables, config: documentConfig } = args;
+    if (!select.length) {
+        return buildFullWithParam({
+            slug,
+            locale,
+            tables
+        });
+    }
+    const withParam = {};
+    // Track paths for different field types
+    const directRelationPaths = [];
+    const blockPaths = [];
+    const treePaths = [];
+    for (const path of select) {
+        // Convert dot notation to double underscore notation for SQLite queries
+        const sqlPath = path.replace(/\./g, '__');
+        const fieldConfig = getFieldConfigByPath(path, documentConfig.fields.map((f) => f.compile()));
+        if (fieldConfig && isRelationField(fieldConfig)) {
+            // Handle relation fields
+            directRelationPaths.push(path);
+            if (!withParam[`${slug}Rels`]) {
+                withParam[`${slug}Rels`] = {
+                    orderBy: [asc(tables[`${slug}Rels`].path), asc(tables[`${slug}Rels`].position)]
+                };
+            }
+        }
+        else if (fieldConfig && isBlocksFieldRaw(fieldConfig)) {
+            // Handle blocks fields
+            blockPaths.push(path);
+            const blocksTables = getBlocksTableNames(slug, tables);
+            for (const blocksTable of blocksTables) {
+                if (!withParam[blocksTable]) {
+                    const blocksTableObj = tables[blocksTable];
+                    let params = { orderBy: [asc(blocksTableObj.position)] };
+                    const columns = getTableColumns(blocksTableObj);
+                    const hasLocale = Object.keys(columns).includes('locale');
+                    if (locale && hasLocale) {
+                        params = { ...params, where: eq(blocksTableObj.locale, locale) };
+                    }
+                    withParam[blocksTable] = params;
+                    // Handle localized blocks
+                    const localesBlockTable = withLocalesSuffix(blocksTable);
+                    if (locale && localesBlockTable in tables) {
+                        withParam[blocksTable] = {
+                            ...withParam[blocksTable],
+                            with: {
+                                [localesBlockTable]: {
+                                    where: eq(tables[localesBlockTable].locale, locale)
+                                }
+                            }
+                        };
+                    }
+                }
+            }
+        }
+        else if (fieldConfig && isTreeFieldRaw(fieldConfig)) {
+            // Handle tree fields
+            treePaths.push(path);
+            const treeTables = getTreeTableNames(slug, tables);
+            for (const treeTable of treeTables) {
+                if (!withParam[treeTable]) {
+                    const treeTableObj = tables[treeTable];
+                    let params = { orderBy: [asc(treeTableObj.position)] };
+                    const columns = getTableColumns(treeTableObj);
+                    const hasLocale = Object.keys(columns).includes('locale');
+                    if (locale && hasLocale) {
+                        params = { ...params, where: eq(treeTableObj.locale, locale) };
+                    }
+                    withParam[treeTable] = params;
+                    // Handle localized trees
+                    const localesTreeTables = withLocalesSuffix(treeTable);
+                    if (locale && localesTreeTables in tables) {
+                        withParam[treeTable] = {
+                            ...withParam[treeTable],
+                            with: {
+                                [localesTreeTables]: {
+                                    where: eq(tables[localesTreeTables].locale, locale)
+                                }
+                            }
+                        };
+                    }
+                }
+            }
+        }
+        else if (fieldConfig) {
+            // Handle regular fields
+            if (fieldConfig.localized && locale) {
+                const localesTableName = withLocalesSuffix(slug);
+                if (localesTableName in tables) {
+                    const tableLocales = tables[localesTableName];
+                    if (withParam[localesTableName]) {
+                        withParam[localesTableName].columns = {
+                            ...withParam[localesTableName].columns,
+                            [sqlPath]: true
+                        };
+                    }
+                    else {
+                        withParam[localesTableName] = {
+                            where: eq(tableLocales.locale, locale),
+                            columns: { [sqlPath]: true }
+                        };
+                    }
+                }
+            }
+        }
+    }
+    // Handle nested relationships
+    // 1. Include relations table if we have any container paths (blocks or trees)
+    if ((directRelationPaths.length > 0 || blockPaths.length > 0 || treePaths.length > 0) &&
+        `${slug}Rels` in tables &&
+        !withParam[`${slug}Rels`]) {
+        const relsTable = tables[`${slug}Rels`];
+        if (blockPaths.length > 0 || treePaths.length > 0) {
+            // Create a where condition that matches relations within any of the container paths
+            withParam[`${slug}Rels`] = {
+                where: (relation, { like, or }) => {
+                    const conditions = [];
+                    // Add conditions for block paths
+                    for (const path of blockPaths) {
+                        conditions.push(like(relation.path, `${path}__%`));
+                    }
+                    // Add conditions for tree paths
+                    for (const path of treePaths) {
+                        conditions.push(like(relation.path, `${path}__%`));
+                    }
+                    // Add direct relation paths if any
+                    for (const path of directRelationPaths) {
+                        conditions.push(like(relation.path, path));
+                    }
+                    return or(...conditions);
+                },
+                orderBy: [asc(relsTable.path), asc(relsTable.position)]
+            };
+        }
+        else {
+            // If we only have direct relation paths, use the standard approach
+            withParam[`${slug}Rels`] = {
+                orderBy: [asc(relsTable.path), asc(relsTable.position)]
+            };
+        }
+    }
+    // 2. Include tree tables for blocks that might contain trees
+    if (blockPaths.length > 0) {
+        const treeTables = getTreeTableNames(slug, tables);
+        for (const treeTable of treeTables) {
+            if (!withParam[treeTable]) {
+                const treeTableObj = tables[treeTable];
+                withParam[treeTable] = {
+                    where: (tree, { like, or }) => {
+                        const conditions = blockPaths.map((path) => {
+                            return like(tree.path, `${path}__%`);
+                        });
+                        return or(...conditions);
+                    },
+                    orderBy: [asc(treeTableObj.position)]
+                };
+                // Handle localized trees
+                const localesTreeTable = withLocalesSuffix(treeTable);
+                if (locale && localesTreeTable in tables) {
+                    withParam[treeTable] = {
+                        ...withParam[treeTable],
+                        with: {
+                            [localesTreeTable]: {
+                                where: eq(tables[localesTreeTable].locale, locale)
+                            }
+                        }
+                    };
+                }
+            }
+        }
+    }
+    // 3. Include block tables for trees that might contain blocks
+    if (treePaths.length > 0) {
+        const blocksTables = getBlocksTableNames(slug, tables);
+        for (const blocksTable of blocksTables) {
+            if (!withParam[blocksTable]) {
+                const blocksTableObj = tables[blocksTable];
+                withParam[blocksTable] = {
+                    where: (block, { like, or }) => {
+                        const conditions = treePaths.map((path) => {
+                            return like(block.path, `${path}__%`);
+                        });
+                        return or(...conditions);
+                    },
+                    orderBy: [asc(blocksTableObj.position)]
+                };
+                // Handle localized blocks
+                const localesBlockTable = withLocalesSuffix(blocksTable);
+                if (locale && localesBlockTable in tables) {
+                    withParam[blocksTable] = {
+                        ...withParam[blocksTable],
+                        with: {
+                            [localesBlockTable]: {
+                                where: eq(tables[localesBlockTable].locale, locale)
+                            }
+                        }
+                    };
+                }
+            }
+        }
+    }
+    // If withParam is empty
+    if (Object.keys(withParam).length === 0) {
+        return undefined;
+    }
+    return withParam;
+};
+const buildFullWithParam = ({ slug, locale, tables }) => {
+    const blocksTables = getBlocksTableNames(slug, tables);
+    const treeTables = getTreeTableNames(slug, tables);
+    const withParam = Object.fromEntries([...blocksTables, ...treeTables].map((key) => {
+        const blockOrTreeTable = tables[key];
+        let params = { orderBy: [asc(blockOrTreeTable.position)] };
+        const columns = getTableColumns(blockOrTreeTable);
+        const hasLocale = Object.keys(columns).includes('locale');
+        if (locale && hasLocale) {
+            params = { ...params, where: eq(blockOrTreeTable.locale, locale) };
+        }
+        return [key, params];
+    }));
+    if (locale) {
+        const localesTableName = withLocalesSuffix(slug);
+        if (localesTableName in tables) {
+            const tableLocales = tables[localesTableName];
+            withParam[localesTableName] = { where: eq(tableLocales.locale, locale) };
+        }
+        for (const blocksTable of blocksTables) {
+            const localesBlockTable = withLocalesSuffix(blocksTable);
+            if (localesBlockTable in tables) {
+                withParam[blocksTable] = {
+                    ...withParam[blocksTable],
+                    with: {
+                        [localesBlockTable]: {
+                            where: eq(tables[localesBlockTable].locale, locale)
+                        }
+                    }
+                };
+            }
+        }
+        for (const treeTable of treeTables) {
+            const localesTreeTable = withLocalesSuffix(treeTable);
+            if (localesTreeTable in tables) {
+                withParam[treeTable] = {
+                    ...withParam[treeTable],
+                    with: {
+                        [localesTreeTable]: {
+                            where: eq(tables[localesTreeTable].locale, locale)
+                        }
+                    }
+                };
+            }
+        }
+    }
+    if (`${slug}Rels` in tables) {
+        const tableNameRelationFields = `${slug}Rels`;
+        const tableRelationFields = tables[tableNameRelationFields];
+        withParam[tableNameRelationFields] = {
+            orderBy: [asc(tableRelationFields.path), asc(tableRelationFields.position)]
+        };
+    }
+    return withParam;
+};

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

@@ -0,0 +1,7 @@
+/**
+ * Build the api full url for given segments
+ * @example
+ * apiUrl('some-collection') // -> http://localhost:5713/api/some-collection
+ * apiUrl('some-collection', '12345') // -> http://localhost:5713/api/some-collection/12345
+ */
+export declare function apiUrl(...args: string[]): string;

package/dist/core/api/index.js

@@ -0,0 +1,10 @@
+import { env } from '$env/dynamic/public';
+/**
+ * Build the api full url for given segments
+ * @example
+ * apiUrl('some-collection') // -> http://localhost:5713/api/some-collection
+ * apiUrl('some-collection', '12345') // -> http://localhost:5713/api/some-collection/12345
+ */
+export function apiUrl(...args) {
+    return `${env.PUBLIC_RIME_URL}/api/${args.join('/')}`;
+}

package/dist/core/api/index.server.d.ts

@@ -0,0 +1,3 @@
+import area from '../areas/api/index.server.js';
+import collection from '../collections/api/index.server.js';
+export { area, collection };

package/dist/core/api/index.server.js

@@ -0,0 +1,3 @@
+import area from '../areas/api/index.server.js';
+import collection from '../collections/api/index.server.js';
+export { area, collection };

package/dist/core/areas/api/get.server.d.ts

@@ -0,0 +1,16 @@
+import type { AreaSlug } from '../../types/doc.js';
+import { type RequestEvent } from '@sveltejs/kit';
+export default function (slug: AreaSlug): (event: RequestEvent) => Promise<Response | import("@sveltejs/kit").ActionFailure<{
+    form: Record<string, any>;
+    errors: import("../../../types").FormErrors;
+}> | import("@sveltejs/kit").ActionFailure<{
+    form: Record<string, any>;
+    errors: {
+        email: string;
+    };
+}> | import("@sveltejs/kit").ActionFailure<{
+    form: {};
+    errors: {
+        _form: string;
+    };
+}>>;

package/dist/core/areas/api/get.server.js

@@ -0,0 +1,32 @@
+import { PARAMS } from '../../constant.js';
+import { handleError } from '../../errors/handler.server.js';
+import { trycatch } from '../../../util/function.js';
+import { json } from '@sveltejs/kit';
+export default function (slug) {
+    //
+    async function GET(event) {
+        const { rime } = event.locals;
+        const params = event.url.searchParams;
+        const areaAPI = rime.area(slug);
+        function buildSelect(params) {
+            const paramSelect = params.get(PARAMS.SELECT) ? params.get(PARAMS.SELECT).split(',') : undefined;
+            if (paramSelect && paramSelect.includes('title') && !paramSelect.includes(areaAPI.config.asTitle)) {
+                paramSelect.push(areaAPI.config.asTitle);
+            }
+            return paramSelect;
+        }
+        const apiParams = {
+            locale: rime.getLocale(),
+            draft: params.get(PARAMS.DRAFT) ? params.get(PARAMS.DRAFT) === 'true' : undefined,
+            versionId: params.get(PARAMS.VERSION_ID) || undefined,
+            depth: params.get(PARAMS.DEPTH) ? parseInt(params.get(PARAMS.DEPTH)) : 0,
+            select: buildSelect(params)
+        };
+        const [error, doc] = await trycatch(() => rime.area(slug).find(apiParams));
+        if (error) {
+            return handleError(error, { context: 'api' });
+        }
+        return json({ doc });
+    }
+    return GET;
+}

package/dist/core/areas/api/index.server.d.ts

@@ -0,0 +1,7 @@
+import get from './get.server.js';
+import update from './update.server.js';
+declare const operations: {
+    get: typeof get;
+    update: typeof update;
+};
+export default operations;

package/dist/core/areas/api/index.server.js

@@ -0,0 +1,4 @@
+import get from './get.server.js';
+import update from './update.server.js';
+const operations = { get, update };
+export default operations;

package/dist/core/areas/api/update.server.d.ts

@@ -0,0 +1,16 @@
+import type { AreaSlug } from '../../types/doc.js';
+import { type RequestEvent } from '@sveltejs/kit';
+export default function (slug: AreaSlug): (event: RequestEvent) => Promise<Response | import("@sveltejs/kit").ActionFailure<{
+    form: Record<string, any>;
+    errors: import("../../../types").FormErrors;
+}> | import("@sveltejs/kit").ActionFailure<{
+    form: Record<string, any>;
+    errors: {
+        email: string;
+    };
+}> | import("@sveltejs/kit").ActionFailure<{
+    form: {};
+    errors: {
+        _form: string;
+    };
+}>>;

package/dist/core/areas/api/update.server.js

@@ -0,0 +1,33 @@
+import { PARAMS } from '../../constant.js';
+import { handleError } from '../../errors/handler.server.js';
+import { extractData } from '../../operations/extract-data.server.js';
+import { trycatch } from '../../../util/function.js';
+import { json } from '@sveltejs/kit';
+export default function (slug) {
+    //
+    async function POST(event) {
+        const { rime } = event.locals;
+        const versionId = event.url.searchParams.get(PARAMS.VERSION_ID) || undefined;
+        const draft = event.url.searchParams.get(PARAMS.DRAFT)
+            ? event.url.searchParams.get(PARAMS.DRAFT) === 'true'
+            : undefined;
+        const [extractError, data] = await trycatch(() => extractData(event.request));
+        if (extractError) {
+            return handleError(extractError, { context: 'api' });
+        }
+        if (data.locale) {
+            rime.setLocale(data.locale);
+        }
+        const [error, doc] = await trycatch(() => rime.area(slug).update({
+            data,
+            versionId,
+            draft,
+            locale: rime.getLocale()
+        }));
+        if (error) {
+            return handleError(error, { context: 'api' });
+        }
+        return json({ doc });
+    }
+    return POST;
+}

package/dist/core/areas/config/augment-hooks.server.d.ts

@@ -0,0 +1,10 @@
+import type { Area, AreaHooks } from '../../../types.js';
+type PartialConfig = {
+    $hooks?: AreaHooks<any>;
+    $url?: Area<any>['$url'];
+};
+/**
+ * Augment an area config with hooks
+ */
+export declare const augmentHooks: <T extends PartialConfig>(area: T) => T;
+export {};

package/dist/core/areas/config/augment-hooks.server.js

@@ -0,0 +1,51 @@
+import { authorize } from '../../operations/hooks/before-operation/authorize.server.js';
+import { populateURL } from '../../operations/hooks/before-read/populate-url.server.js';
+import { processDocumentFields } from '../../operations/hooks/before-read/process-document-fields.server.js';
+import { setDocumentLocale } from '../../operations/hooks/before-read/set-document-locale.server.js';
+import { setDocumentTitle } from '../../operations/hooks/before-read/set-document-title.server.js';
+import { setDocumentType } from '../../operations/hooks/before-read/set-document-type.server.js';
+import { sortDocumentProps } from '../../operations/hooks/before-read/sort-document-props.server.js';
+import { defineVersionOperation } from '../../operations/hooks/before-update/define-version-operation.server.js';
+import { getOriginalDocument } from '../../operations/hooks/before-update/get-original-document.server.js';
+import { buildDataConfigMap } from '../../operations/hooks/before-upsert/data-config-map.server.js';
+import { handleNewVersion } from '../../operations/hooks/before-upsert/handle-new-version.server.js';
+import { buildOriginalDocConfigMap } from '../../operations/hooks/before-upsert/original-config-map.server.js';
+import { setDefaultValues } from '../../operations/hooks/before-upsert/set-default-values.server.js';
+import { validateFields } from '../../operations/hooks/before-upsert/validate-fields.server.js';
+/**
+ * Augment an area config with hooks
+ */
+export const augmentHooks = (area) => {
+    const hooks = {
+        beforeOperation: [authorize],
+        beforeRead: [
+            //
+            processDocumentFields,
+            setDocumentTitle,
+            setDocumentLocale,
+            ...(area.$url ? [populateURL] : []),
+            setDocumentType,
+            sortDocumentProps
+        ],
+        beforeUpdate: [
+            //
+            defineVersionOperation,
+            getOriginalDocument,
+            buildOriginalDocConfigMap,
+            handleNewVersion,
+            buildDataConfigMap,
+            setDefaultValues,
+            validateFields
+        ],
+        afterUpdate: []
+    };
+    return {
+        ...area,
+        $hooks: {
+            beforeOperation: [...hooks.beforeOperation, ...(area.$hooks?.beforeOperation || [])],
+            beforeUpdate: [...hooks.beforeUpdate, ...(area.$hooks?.beforeUpdate || [])],
+            afterUpdate: [...hooks.afterUpdate, ...(area.$hooks?.afterUpdate || [])],
+            beforeRead: [...hooks.beforeRead, ...(area.$hooks?.beforeRead || [])]
+        }
+    };
+};

package/dist/core/areas/config/augment-metas.d.ts

@@ -0,0 +1,10 @@
+import type { Area } from '../../../types.js';
+type Input = {
+    fields: Area<any>['fields'];
+};
+/**
+ * Add updatedAt createdAt editedBy fields
+ * to an Area
+ */
+export declare const augmentMetas: <T extends Input>(config: T) => T;
+export {};

package/dist/core/areas/config/augment-metas.js

@@ -0,0 +1,13 @@
+import { date } from '../../../fields/date/index.js';
+import { text } from '../../../fields/text/index.js';
+/**
+ * Add updatedAt createdAt editedBy fields
+ * to an Area
+ */
+export const augmentMetas = (config) => {
+    const fields = [...config.fields];
+    fields.push(
+    //
+    text('editedBy').hidden(), date('createdAt').hidden(), date('updatedAt').hidden());
+    return { ...config, fields };
+};

package/dist/core/areas/config/augment-title.d.ts

@@ -0,0 +1,9 @@
+import type { Area } from '../../../types.js';
+type Input = {
+    fields: Area<any>['fields'];
+};
+type WithAsTitle<T> = T & {
+    asTitle: string;
+};
+export declare const augmentTitle: <T extends Input>(config: T) => WithAsTitle<T>;
+export {};

package/dist/core/areas/config/augment-title.js

@@ -0,0 +1,8 @@
+import { findTitleField } from '../../config/shared/find-title.js';
+export const augmentTitle = (config) => {
+    const fieldTitle = findTitleField(config.fields);
+    return {
+        ...config,
+        asTitle: fieldTitle ? fieldTitle.path : 'id'
+    };
+};

package/dist/core/areas/config/augment-url.d.ts

@@ -0,0 +1,10 @@
+import type { Area } from '../../../types.js';
+type Input = {
+    $url?: Area<any>['$url'];
+    fields: Area<any>['fields'];
+};
+/**
+ * Add url field
+ */
+export declare const augmentUrl: <T extends Input>(config: T) => T;
+export {};

package/dist/core/areas/config/augment-url.js

@@ -0,0 +1,14 @@
+import { text } from '../../../fields/text/index.js';
+/**
+ * Add url field
+ */
+export const augmentUrl = (config) => {
+    let fields = [...config.fields];
+    if (config.$url) {
+        fields = [...fields, text('url').localized().hidden()];
+    }
+    return {
+        ...config,
+        fields
+    };
+};

package/dist/core/areas/config/augment-versions.d.ts

@@ -0,0 +1,14 @@
+import type { VersionsConfig } from '../../config/types.js';
+import type { Area } from '../../../types.js';
+type Input = {
+    versions?: Area<any>['versions'];
+    fields: Area<any>['fields'];
+};
+type WithVersionsConfig<T> = Omit<T, 'versions'> & {
+    versions?: Required<VersionsConfig>;
+};
+/**
+ * Normalize versions prop and add status field if config.versions.drat is true
+ */
+export declare const augmentVersions: <T extends Input>(config: T) => WithVersionsConfig<T>;
+export {};

package/dist/core/areas/config/augment-versions.js

@@ -0,0 +1,25 @@
+import { VERSIONS_STATUS } from '../../constant.js';
+import { text } from '../../../fields/text/index.js';
+/**
+ * Normalize versions prop and add status field if config.versions.drat is true
+ */
+export const augmentVersions = (config) => {
+    const fields = [...config.fields];
+    const { versions, ...rest } = config;
+    let normalizedVersions;
+    if (versions) {
+        // Create a properly typed object with all required properties
+        normalizedVersions = {
+            draft: typeof versions === 'boolean' ? false : (versions.draft ?? false),
+            autoSave: typeof versions === 'boolean' ? false : (versions.autoSave ?? false),
+            maxVersions: typeof versions === 'boolean' ? 12 : (versions.maxVersions ?? 12)
+        };
+        if (normalizedVersions.draft) {
+            fields.push(text('status').defaultValue(VERSIONS_STATUS.DRAFT).hidden());
+        }
+    }
+    else {
+        normalizedVersions = undefined;
+    }
+    return { ...rest, versions: normalizedVersions, fields };
+};

package/dist/core/areas/config/builder.d.ts

@@ -0,0 +1,3 @@
+import type { AreaWithoutSlug } from './types.js';
+import type { BuiltArea } from '../../config/types.js';
+export declare const create: <S extends string>(slug: S, incomingConfig: AreaWithoutSlug<S>) => BuiltArea;

package/dist/core/areas/config/builder.js

@@ -0,0 +1,33 @@
+import { augmentMetas } from './augment-metas.js';
+import { augmentTitle } from './augment-title.js';
+import { augmentUrl } from './augment-url.js';
+import { augmentVersions } from './augment-versions.js';
+import { capitalize, toKebabCase } from '../../../util/string.js';
+import { FileText } from '@lucide/svelte';
+export const create = (slug, incomingConfig) => {
+    const area = { ...incomingConfig, slug };
+    const initial = { ...area };
+    const withMetas = augmentMetas(initial);
+    const withVersions = augmentVersions(withMetas);
+    const withUrl = augmentUrl(withVersions);
+    const augmented = augmentTitle(withUrl);
+    return {
+        type: 'area',
+        slug: augmented.slug,
+        kebab: toKebabCase(augmented.slug),
+        icon: augmented.icon || FileText,
+        label: augmented.label ? augmented.label : capitalize(area.slug),
+        fields: augmented.fields,
+        asTitle: augmented.asTitle,
+        versions: augmented.versions,
+        live: incomingConfig.live || false,
+        panel: incomingConfig.panel,
+        access: {
+            create: (user) => !!user && !!user.isStaff,
+            read: (user) => !!user && !!user.isStaff,
+            update: (user) => !!user && !!user.isStaff,
+            delete: (user) => !!user && !!user.isStaff,
+            ...augmented.access
+        }
+    };
+};

package/dist/core/areas/config/builder.server.d.ts

@@ -0,0 +1,16 @@
+import type { AreaWithoutSlug } from './types.js';
+import type { BuiltArea } from '../../config/types.js';
+export declare const create: <S extends string>(slug: S, incomingConfig: AreaWithoutSlug<S>) => BuiltArea;
+export declare const hook: {
+    beforeOperation: <S extends import("../../types/doc").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").HookBeforeOperation<S, import("../../operations/hooks/index.server.js").Operation>) => import("../../operations/hooks/index.server.js").HookBeforeOperation<S, import("../../operations/hooks/index.server.js").Operation>;
+    beforeRead: <S extends import("../../types/doc").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").Hook<S, "read", "before">) => import("../../operations/hooks/index.server.js").Hook<S, "read", "before">;
+    beforeCreate: <S extends import("../../types/doc").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").Hook<S, "create", "before">) => import("../../operations/hooks/index.server.js").Hook<S, "create", "before">;
+    beforeUpsert: <S extends import("../../types/doc").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").Hook<S, "create" | "update", "before">) => import("../../operations/hooks/index.server.js").Hook<S, "create" | "update", "before">;
+    beforeUpdate: <S extends import("../../types/doc").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").Hook<S, "update", "before">) => import("../../operations/hooks/index.server.js").Hook<S, "update", "before">;
+    beforeDelete: <S extends import("../../types/doc").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").Hook<S, "delete", "before">) => import("../../operations/hooks/index.server.js").Hook<S, "delete", "before">;
+    afterRead: <S extends import("../../types/doc").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").Hook<S, "read", "after">) => import("../../operations/hooks/index.server.js").Hook<S, "read", "after">;
+    afterCreate: <S extends import("../../types/doc").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").Hook<S, "create", "after">) => import("../../operations/hooks/index.server.js").Hook<S, "create", "after">;
+    afterUpsert: <S extends import("../../types/doc").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").Hook<S, "create" | "update", "after">) => import("../../operations/hooks/index.server.js").Hook<S, "create" | "update", "after">;
+    afterUpdate: <S extends import("../../types/doc").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").Hook<S, "update", "after">) => import("../../operations/hooks/index.server.js").Hook<S, "update", "after">;
+    afterDelete: <S extends import("../../types/doc").DocType = "raw">(handler: import("../../operations/hooks/index.server.js").Hook<S, "delete", "after">) => import("../../operations/hooks/index.server.js").Hook<S, "delete", "after">;
+};