rimecms 0.31.5 → 0.32.1

package/dist/core/prototype/collection/operations/delete.js

@@ -0,0 +1,34 @@
+import { runBeforeOperation } from '../../../pipeline/run.server.js';
+export const deleteDocs = async (args) => {
+    const { ctx, locale, limit, offset, sort, query } = args;
+    const { config, event, isSystemOperation } = ctx;
+    const { rime } = event.locals;
+    await runBeforeOperation({
+        config,
+        event,
+        operation: 'delete',
+        context: {
+            params: { locale, limit, offset, sort, query },
+            isSystemOperation
+        }
+    });
+    const documentsToDelete = await rime.adapter.collection(config.slug).findMany({
+        query,
+        limit,
+        offset,
+        sort,
+        select: ['id'],
+        locale
+        // No `content`: see deleteById.
+    });
+    // Each row is deleted as this operation was asked: a system delete stays a system delete,
+    // through to each row's access check and hooks.
+    const collection = isSystemOperation
+        ? rime.collection(config.slug).system()
+        : rime.collection(config.slug);
+    const promisesDelete = documentsToDelete.map(({ id }) => {
+        return collection.deleteById({ id });
+    });
+    const ids = await Promise.all(promisesDelete);
+    return ids;
+};

package/dist/core/prototype/collection/operations/duplicate.d.ts

@@ -0,0 +1,12 @@
+import type { BuiltCollection } from '../../../config/types.js';
+import type { PrototypeApiContext } from '../../define.js';
+export type DuplicateArgs = {
+    id: string;
+    /** The row to copy. Without it, the newest real version; with it, that row, auto-saved or not. */
+    versionId?: string;
+};
+type Args = DuplicateArgs & {
+    ctx: PrototypeApiContext<BuiltCollection>;
+};
+export declare const duplicate: (args: Args) => Promise<string>;
+export {};

package/dist/core/prototype/collection/operations/duplicate.js

@@ -0,0 +1,112 @@
+import { copyLocales } from '../../../locale/copy.server.js';
+import { isJSONContent, richTextJSONToText } from '../../../../fields/rich-text/index.js';
+import { getValueAtPath, isObjectLiteral, setValueAtPath } from '../../../../util/object.js';
+// If block is localized should not keep its id so it created a new one
+// If block is not localized than it should keep its id so block is updated
+export const duplicate = async (args) => {
+    const { ctx, id, versionId } = args;
+    const { config, event } = ctx;
+    const { rime } = event.locals;
+    /**
+     * Set a copy title, ex: Current Title (copy)
+     * on the given document
+     */
+    function setCopyTitle(doc) {
+        // For upload collections with no real title field, asTitle falls back to
+        // 'filename' (see augmentTitle) — that's a display fallback, not a
+        // mutable title. filename must keep matching the actual file on disk
+        // (saveFile dedupes by content), so leave it alone rather than
+        // corrupting the reference with a suffix no file on disk has.
+        if (config.upload && config.asTitle === 'filename')
+            return doc;
+        const getTitle = () => {
+            const title = getValueAtPath(config.asTitle, doc);
+            return isJSONContent(title)
+                ? richTextJSONToText(title) + ' (copy)'
+                : title + ' (copy)';
+        };
+        const data = setValueAtPath(config.asTitle, doc, getTitle());
+        return data;
+    }
+    /**
+     * Prepare duplication:
+     * - set the copy title
+     * - drop what a copy does not inherit
+     * - normalize properties
+     */
+    function prepareDuplicate(doc, locale) {
+        let data = setCopyTitle(doc);
+        data = normalizeProps(data, locale);
+        delete data.id;
+        /**
+         * A copy is a new document, so it starts where a new document starts.
+         *
+         * This was `data.status = data.status ? VERSIONS_STATUS.DRAFT : undefined` — a core operation
+         * naming a feature's vocabulary to say "a copy of a published document is not published".
+         * True, and not this operation's rule: the feature that adds `status` already declares its
+         * default, and `setDefaultValues` applies it on every create. Carrying the original's value
+         * over is what made the reset necessary.
+         *
+         * Unconditional, and safe for a config with no such field: `delete` on an absent key is a
+         * no-op, which is what the `data.status ?` test was standing in for.
+         */
+        delete data.status;
+        return data;
+    }
+    // Store currrent locale
+    const currentLocale = event.locals.locale;
+    // Get the collection api
+    const collection = rime.collection(config.slug);
+    // Get the defaultLocale to copy first from the default locale
+    const defaultLocale = rime.config.getDefaultLocale();
+    // Set locale to the default one
+    if (defaultLocale)
+        rime.setLocale(defaultLocale);
+    // The row asked for, or the newest real one — `latest`, since the source may never have been
+    // published.
+    const document = await collection.findById({
+        id,
+        locale: defaultLocale,
+        versionId,
+        latest: true,
+        localeFallback: false
+    });
+    // Prepare data
+    const data = prepareDuplicate(document, defaultLocale);
+    // Create document
+    const newDocument = (await collection.create({ data, locale: defaultLocale }));
+    // The other locales, copied from the source onto the new document.
+    const otherLocales = rime.config.getLocalesCodes().filter((l) => l !== defaultLocale);
+    if (otherLocales.length) {
+        await copyLocales({
+            event,
+            config,
+            source: { id, versionId, latest: true },
+            target: {
+                id: newDocument.id,
+                versionId: newDocument.versionId,
+                doc: newDocument
+            },
+            locales: otherLocales,
+            prepare: (data) => setCopyTitle(data)
+        });
+    }
+    // Reset event locale
+    rime.setLocale(currentLocale);
+    return newDocument.id;
+};
+const normalizeProps = (value, locale) => {
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizeProps(item, locale));
+    }
+    if (!isObjectLiteral(value)) {
+        return value;
+    }
+    const unwantedProps = ['id', 'ownerId', 'createdAt', 'updatedAt', 'createdBy', 'updatedBy'];
+    return Object.entries(value)
+        .filter(([key]) => !unwantedProps.includes(key))
+        .reduce((acc, [key, value]) => ({
+        ...acc,
+        [key]: normalizeProps(value, locale)
+    }), {});
+};

package/dist/core/prototype/collection/operations/find-by-id.d.ts

@@ -0,0 +1,22 @@
+import type { BuiltCollection } from '../../../config/types.js';
+import type { PrototypeApiContext } from '../../define.js';
+import type { GenericDoc } from '../../types.js';
+export type FindByIdArgs = {
+    id: string;
+    versionId?: string;
+    locale?: string | undefined;
+    depth?: number;
+    select?: string[];
+    /** The newest version, whatever its status; the published one otherwise. `PARAMS.LATEST`. */
+    latest?: boolean;
+    /**
+     * Whether a field the locale has not written reads from the other locales. `true` unless said
+     * otherwise; `false` is the locale's own rows, which is what a copy onto another row reads.
+     */
+    localeFallback?: boolean;
+};
+type Args = FindByIdArgs & {
+    ctx: PrototypeApiContext<BuiltCollection>;
+};
+export declare const findById: <T extends GenericDoc>(args: Args) => Promise<T>;
+export {};

package/dist/core/prototype/collection/operations/find-by-id.js

@@ -0,0 +1,47 @@
+import { RimeError } from '../../../errors/index.js';
+import { readDocument, runBeforeOperation } from '../../../pipeline/run.server.js';
+export const findById = async (args) => {
+    const { ctx, id, versionId, locale, depth, select, latest, localeFallback } = args;
+    const { config, event, isSystemOperation } = ctx;
+    const { rime } = event.locals;
+    let context = {
+        params: {
+            id,
+            versionId,
+            locale,
+            depth,
+            latest,
+            select
+        },
+        isSystemOperation
+    };
+    context = await runBeforeOperation({
+        config,
+        event,
+        operation: 'read',
+        context
+    });
+    const documentRaw = await rime.adapter.collection(config.slug).find({
+        id,
+        locale,
+        localeFallback,
+        select,
+        // `draft` and `versionId` are request parameters; which row they name is the feature's answer.
+        content: ctx.versionQuery({ latest, versionId })
+    });
+    // The adapter reports "nothing matched" and leaves the meaning to the caller, so an HTTP-shaped
+    // decision like this one stays out of the database layer.
+    if (!documentRaw)
+        throw new RimeError(RimeError.NOT_FOUND);
+    const { doc } = await readDocument({
+        raw: documentRaw,
+        config,
+        event,
+        context,
+        locale,
+        localeFallback,
+        depth,
+        select
+    });
+    return doc;
+};

package/dist/core/prototype/collection/operations/find.d.ts

@@ -0,0 +1,22 @@
+import type { BuiltCollection } from '../../../config/types.js';
+import type { OperationQuery } from '../../../pipeline/types.js';
+import type { PrototypeApiContext } from '../../define.js';
+import type { GenericDoc } from '../../types.js';
+export type FindArgs = {
+    query?: OperationQuery;
+    locale?: string | undefined;
+    sort?: string;
+    depth?: number;
+    limit?: number;
+    offset?: number;
+    select?: string[];
+    /** The newest version of each, whatever its status; the published one otherwise. */
+    latest?: boolean;
+    /** See the collection's findById. */
+    localeFallback?: boolean;
+};
+type Args = FindArgs & {
+    ctx: PrototypeApiContext<BuiltCollection>;
+};
+export declare const find: <T extends GenericDoc>(args: Args) => Promise<T[]>;
+export {};

package/dist/core/prototype/collection/operations/find.js

@@ -0,0 +1,65 @@
+import { logger } from '../../../logger.server.js';
+import { readDocument, runBeforeOperation } from '../../../pipeline/run.server.js';
+export const find = async (args) => {
+    //
+    const { ctx, locale, sort, limit, offset, depth, query, latest, select = [], localeFallback } = args;
+    const { config, event, isSystemOperation } = ctx;
+    const { rime } = event.locals;
+    let context = {
+        isSystemOperation,
+        params: {
+            query,
+            sort,
+            limit,
+            offset,
+            locale,
+            select,
+            latest,
+            depth
+        }
+    };
+    context = await runBeforeOperation({
+        config,
+        event,
+        operation: 'read',
+        context
+    });
+    const documentsRaw = await rime.adapter.collection(config.slug).findMany({
+        query,
+        sort,
+        limit,
+        offset,
+        locale,
+        localeFallback,
+        select,
+        // Which content row each document shows. `and`ed with `query` by the adapter, rather than
+        // spliced into it — see the collection's findById for where the answer comes from.
+        content: ctx.versionQuery({ latest })
+    });
+    async function processDocument(documentRaw) {
+        try {
+            const result = await readDocument({
+                raw: documentRaw,
+                config,
+                event,
+                context,
+                locale,
+                localeFallback,
+                depth,
+                select
+            });
+            context = result.context;
+            return result.doc;
+        }
+        catch (error) {
+            // Skip this document and carry on with the next one. The transform is inside the try
+            // alongside the hooks now: a row rime cannot turn into a document is the same kind of
+            // per-row problem as a beforeRead hook rejecting one, and taking the whole query down
+            // for it made a single bad row look like an empty collection.
+            logger.error(error.message, error);
+            return null;
+        }
+    }
+    const documents = await Promise.all(documentsRaw.map((doc) => processDocument(doc)));
+    return documents.filter((d) => !!d);
+};

package/dist/core/prototype/collection/operations/update-by-id.d.ts

@@ -0,0 +1,30 @@
+import type { BuiltCollection } from '../../../config/types.js';
+import type { PrototypeApiContext } from '../../define.js';
+import type { GenericDoc } from '../../types.js';
+import type { DeepPartial } from '../../../../util/types.js';
+export type UpdateByIdArgs<T> = {
+    id: string;
+    versionId?: string;
+    /** Start from the newest version rather than the published one. `PARAMS.LATEST`. */
+    latest?: boolean;
+    /** Make a new version from the selected row rather than write it. `PARAMS.FORK`. */
+    fork?: boolean;
+    /** Write the caller's auto-saved row of the version `versionId` names. Panel only. */
+    autoSave?: boolean;
+    data: DeepPartial<T>;
+    locale?: string | undefined;
+    /** This write copies another locale's rows onto the row — see `copyLocales`. */
+    isLocaleCopy?: boolean;
+};
+type Args<T> = UpdateByIdArgs<T> & {
+    ctx: PrototypeApiContext<BuiltCollection>;
+};
+/**
+ * Updates a document by ID.
+ *
+ * The pipeline itself lives in operations/run.server.ts — shared with an area's update. Only
+ * the two prototype-specific pieces are here: which adapter method writes the root row, and
+ * how the saved document is read back.
+ */
+export declare const updateById: <T extends GenericDoc = GenericDoc>(args: Args<T>) => Promise<T>;
+export {};

package/dist/core/prototype/collection/operations/update-by-id.js

@@ -0,0 +1,52 @@
+import { runUpdate } from '../../../pipeline/run.server.js';
+/**
+ * Updates a document by ID.
+ *
+ * The pipeline itself lives in operations/run.server.ts — shared with an area's update. Only
+ * the two prototype-specific pieces are here: which adapter method writes the root row, and
+ * how the saved document is read back.
+ */
+export const updateById = async (args) => {
+    const { ctx, locale, id, latest, fork, isLocaleCopy } = args;
+    const { event, isSystemOperation } = ctx;
+    const { rime } = event.locals;
+    const context = {
+        params: {
+            id,
+            versionId: args.versionId,
+            latest,
+            fork,
+            autoSave: args.autoSave,
+            locale
+        },
+        isSystemOperation,
+        isLocaleCopy
+    };
+    return runUpdate({
+        data: args.data,
+        config: ctx.config,
+        event,
+        context,
+        locale,
+        where: 'updateById',
+        // The plan says which rows this write touches; the adapter writes what it is handed.
+        write: ({ plan, config }) => rime.adapter.collection(config.slug).update({ id, ...plan, locale }),
+        /**
+         * Read back **the row the write went to**, not the one the caller asked for.
+         *
+         * `context.contentOwnerId` is what `handleNewVersion` answered and what step 4 wrote to, so on
+         * a new-version update it is the version that was just created — which `params.versionId`
+         * cannot be, since the caller did not name it. Reading `params.versionId` here returned the
+         * *published* version of a `?fork=true` update, unchanged, with a 200.
+         *
+         * `runUpdate` asserts `contentOwnerId` before the write, so it is always set by now. A config
+         * with no versions ignores the parameter entirely (see `readPrototype` in the adapter), where
+         * it is the document's own id anyway.
+         */
+        reread: ({ written, config, context }) => rime.collection(config.slug).findById({
+            id: written.id,
+            locale,
+            versionId: context.contentOwnerId
+        })
+    });
+};

package/dist/core/prototype/collection/rest/create.server.d.ts

@@ -0,0 +1,4 @@
+/**
+ * POST handler for the collection API endpoint.
+ */
+export declare const restCreate: import("@sveltejs/kit").RequestHandler;

package/dist/core/prototype/collection/rest/create.server.js

@@ -0,0 +1,26 @@
+import { ERROR_CONTEXT, handleError } from '../../../errors/handler.server.js';
+import { extractData } from '../../../pipeline/extract-data.server.js';
+import { trycatch } from '../../../../util/function.js';
+import { json } from '@sveltejs/kit';
+import { endpoint } from './endpoint.server.js';
+/**
+ * POST handler for the collection API endpoint.
+ */
+export const restCreate = endpoint(async ({ event, collection }) => {
+    //
+    const { rime } = event.locals;
+    // Extract data from the request body
+    const [extractError, data] = await trycatch(() => extractData(event.request));
+    if (extractError) {
+        return handleError(extractError, { context: ERROR_CONTEXT.API });
+    }
+    // Set the locale if provided in the data
+    if (data.locale) {
+        rime.setLocale(data.locale);
+    }
+    const [error, document] = await trycatch(() => collection.create({ data, locale: rime.getLocale() }));
+    if (error) {
+        return handleError(error, { context: ERROR_CONTEXT.API });
+    }
+    return json({ doc: document });
+});

package/dist/core/prototype/collection/rest/delete-by-id.server.d.ts

@@ -0,0 +1,4 @@
+/**
+ * DELETE handler for the collection API endpoint to delete a document by its ID.
+ */
+export declare const restDeleteById: import("@sveltejs/kit").RequestHandler;

package/dist/core/prototype/collection/rest/delete-by-id.server.js

@@ -0,0 +1,16 @@
+import { handleError } from '../../../errors/handler.server.js';
+import { trycatch } from '../../../../util/function.js';
+import { json } from '@sveltejs/kit';
+import { endpoint } from './endpoint.server.js';
+/**
+ * DELETE handler for the collection API endpoint to delete a document by its ID.
+ */
+export const restDeleteById = endpoint(async ({ event, collection }) => {
+    //
+    const id = event.params.id || '';
+    const [error] = await trycatch(() => collection.deleteById({ id }));
+    if (error) {
+        return handleError(error, { context: 'api' });
+    }
+    return json({ id });
+});

package/dist/core/prototype/collection/rest/delete.server.d.ts

@@ -0,0 +1,4 @@
+/**
+ * DELETE handler for the collection API endpoint.
+ */
+export declare const restDelete: import("@sveltejs/kit").RequestHandler;

package/dist/core/prototype/collection/rest/delete.server.js

@@ -0,0 +1,33 @@
+import { normalizeQuery } from '../../../pipeline/query.js';
+import { PARAMS } from '../../../constants.js';
+import { handleError } from '../../../errors/handler.server.js';
+import { trycatch } from '../../../../util/function.js';
+import { json } from '@sveltejs/kit';
+import { endpoint } from './endpoint.server.js';
+/**
+ * DELETE handler for the collection API endpoint.
+ */
+export const restDelete = endpoint(async ({ event, collection }) => {
+    //
+    const { rime } = event.locals;
+    const params = event.url.searchParams;
+    const hasQueryParams = !!params
+        .keys()
+        .filter((key) => key.startsWith('where'))
+        .toArray().length;
+    const query = hasQueryParams ? normalizeQuery(event.url.search.substring(1)) : undefined;
+    const apiParams = {
+        locale: rime.getLocale(),
+        sort: params.get(PARAMS.SORT) || undefined,
+        depth: params.get(PARAMS.DEPTH) ? parseInt(params.get(PARAMS.DEPTH)) : 0,
+        limit: params.get(PARAMS.LIMIT) ? parseInt(params.get(PARAMS.LIMIT)) : undefined,
+        offset: params.get(PARAMS.OFFSET) ? parseInt(params.get(PARAMS.OFFSET)) : undefined,
+        query,
+        select: params.get(PARAMS.SELECT) ? params.get(PARAMS.SELECT).split(',') : undefined
+    };
+    const [error, docs] = await trycatch(() => collection.delete(apiParams));
+    if (error) {
+        return handleError(error, { context: 'api' });
+    }
+    return json({ docs }, { status: 200 });
+});

package/dist/core/prototype/collection/rest/duplicate.server.d.ts

@@ -0,0 +1 @@
+export declare const restDuplicate: import("@sveltejs/kit").RequestHandler;

package/dist/core/prototype/collection/rest/duplicate.server.js

@@ -0,0 +1,17 @@
+import { PARAMS } from '../../../constants.js';
+import { ERROR_CONTEXT, handleError } from '../../../errors/handler.server.js';
+import { trycatch } from '../../../../util/function.js';
+import { error, json } from '@sveltejs/kit';
+import { endpoint } from './endpoint.server.js';
+export const restDuplicate = endpoint(async ({ event, collection }) => {
+    //
+    if (!event.params.id)
+        throw error(404);
+    // `?versionId=` names the row to copy; without it, the newest real version.
+    const versionId = event.url.searchParams.get(PARAMS.VERSION_ID) || undefined;
+    const [duplicateError, newId] = await trycatch(() => collection.duplicate({ id: event.params.id, versionId }));
+    if (duplicateError) {
+        return handleError(duplicateError, { context: ERROR_CONTEXT.API });
+    }
+    return json({ id: newId });
+});

package/dist/core/prototype/collection/rest/endpoint.server.d.ts

@@ -0,0 +1,27 @@
+import type { RequestEvent, RequestHandler } from '@sveltejs/kit';
+/**
+ * The collection API for this request. Taken from the accessor rather than imported from
+ * `../index.server.js`, which declares it: that import would close a cycle (definition -> rest
+ * -> handler -> here -> definition), and this is the same type by construction — what
+ * `rime.collection(slug)` hands back.
+ */
+type CollectionApi = ReturnType<App.Locals['rime']['collection']>;
+type Run = (args: {
+    event: RequestEvent;
+    collection: CollectionApi;
+}) => Promise<Response>;
+/**
+ * Wraps a collection REST handler with the check every one of them opened with.
+ *
+ * Seven handlers each read `event.params.slug`, refused what was not a collection, and looked up
+ * `rime.collection(slug)` — the same six lines, differing in nothing. The lookup is the reason
+ * the check cannot simply be deleted and left to the param matcher: `isCollection` is a type
+ * guard (`slug is CollectionSlug`), and that narrowing is what makes the accessor typecheck.
+ *
+ * The returned handler's type is annotated rather than inferred on purpose. Inference would walk
+ * a body that mentions the collection API, and this handler ends up inside
+ * `App.Locals['routes']` — the shape that made every `rime.collection(...)` in the repo resolve
+ * to `never` during the local-API move.
+ */
+export declare const endpoint: (run: Run) => RequestHandler;
+export {};

package/dist/core/prototype/collection/rest/endpoint.server.js

@@ -0,0 +1,23 @@
+import { ERROR_CONTEXT, handleError } from '../../../errors/handler.server.js';
+import { RimeError } from '../../../errors/index.js';
+/**
+ * Wraps a collection REST handler with the check every one of them opened with.
+ *
+ * Seven handlers each read `event.params.slug`, refused what was not a collection, and looked up
+ * `rime.collection(slug)` — the same six lines, differing in nothing. The lookup is the reason
+ * the check cannot simply be deleted and left to the param matcher: `isCollection` is a type
+ * guard (`slug is CollectionSlug`), and that narrowing is what makes the accessor typecheck.
+ *
+ * The returned handler's type is annotated rather than inferred on purpose. Inference would walk
+ * a body that mentions the collection API, and this handler ends up inside
+ * `App.Locals['routes']` — the shape that made every `rime.collection(...)` in the repo resolve
+ * to `never` during the local-API move.
+ */
+export const endpoint = (run) => (event) => {
+    const { rime } = event.locals;
+    const slug = event.params.slug;
+    if (!rime.config.isCollection(slug)) {
+        return handleError(new RimeError(RimeError.NOT_FOUND), { context: ERROR_CONTEXT.API });
+    }
+    return run({ event, collection: rime.collection(slug) });
+};

package/dist/core/prototype/collection/rest/get-by-id.server.d.ts

@@ -0,0 +1,4 @@
+/**
+ * GET handler for the collection API endpoint to retrieve a document by its ID.
+ */
+export declare const restGetById: import("@sveltejs/kit").RequestHandler;

package/dist/core/prototype/collection/rest/get-by-id.server.js

@@ -0,0 +1,40 @@
+import { isStaff } from '../../../auth/access.js';
+import { PARAMS } from '../../../constants.js';
+import { RimeError } from '../../../errors/index.js';
+import { handleError } from '../../../errors/handler.server.js';
+import { selectWithTitle } from '../../shared/title/select.js';
+import { trycatch } from '../../../../util/function.js';
+import { json } from '@sveltejs/kit';
+import { endpoint } from './endpoint.server.js';
+/**
+ * GET handler for the collection API endpoint to retrieve a document by its ID.
+ */
+export const restGetById = endpoint(async ({ event, collection }) => {
+    //
+    const { rime } = event.locals;
+    const id = event.params.id;
+    if (!id) {
+        return handleError(new RimeError(RimeError.NOT_FOUND), { context: 'api' });
+    }
+    // A row other than the published one is staff's to see: from anyone else, `latest` and
+    // `versionId` read as absent.
+    const staff = isStaff(event.locals.user);
+    const paramDepth = event.url.searchParams.get(PARAMS.DEPTH);
+    const paramLatest = event.url.searchParams.get(PARAMS.LATEST);
+    const versionId = staff ? event.url.searchParams.get(PARAMS.VERSION_ID) || undefined : undefined;
+    const latest = staff && paramLatest ? paramLatest === 'true' : undefined;
+    const depth = typeof paramDepth === 'string' ? parseInt(paramDepth) : 0;
+    const select = selectWithTitle(event.url.searchParams.get(PARAMS.SELECT), collection.config.asTitle);
+    const [error, document] = await trycatch(() => collection.findById({
+        id,
+        locale: rime.getLocale(),
+        depth,
+        latest,
+        versionId,
+        select
+    }));
+    if (error) {
+        return handleError(error, { context: 'api' });
+    }
+    return json({ doc: document });
+});

package/dist/core/prototype/collection/rest/get.server.d.ts

@@ -0,0 +1,4 @@
+/**
+ * GET handler for the collection API endpoint.
+ */
+export declare const restGet: import("@sveltejs/kit").RequestHandler;