@rolder/kit 3.0.0-alpha.11 → 3.0.0-alpha.111

package/dist/betterAuth/server/surrealDbAdapter/methods/findMany.js

@@ -0,0 +1,51 @@
+import { Table, raw, surql } from "surrealdb";
+import { getDb } from "../db/index.js";
+import { applyJoinMappings, buildExpression, buildJoinPlan, buildSelectFields, normalizeOutputRecordIds } from "../utils/index.js";
+const findMany = async ({ model, where, limit, offset, sortBy, join, surrealDbProps, ...args })=>{
+    const db = await getDb(surrealDbProps);
+    const table = new Table(model);
+    const expression = buildExpression({
+        model,
+        where,
+        ...args
+    });
+    const joinPlan = buildJoinPlan({
+        model,
+        join,
+        ...args
+    });
+    const fields = buildSelectFields(void 0, (field)=>args.getFieldName({
+            model,
+            field
+        }));
+    const baseFields = fields.split(', ');
+    const joinFields = joinPlan.selectFields.filter((field)=>!baseFields.includes(field));
+    const finalFields = [
+        ...baseFields,
+        ...joinFields
+    ].join(', ');
+    const query = surql`SELECT ${raw(finalFields)} FROM ${table}`;
+    if (expression) query.append(surql` WHERE ${expression}`);
+    if (sortBy) {
+        const orderField = args.getFieldName({
+            model,
+            field: sortBy.field
+        });
+        const direction = sortBy.direction.toUpperCase();
+        query.append(surql` ORDER BY ${raw(orderField)} ${raw(direction)}`);
+    }
+    if ('number' == typeof offset) query.append(surql` START ${offset}`);
+    query.append(surql` LIMIT ${limit}`);
+    if (joinPlan.fetchFields.size > 0) query.append(surql` FETCH ${raw(Array.from(joinPlan.fetchFields).join(', '))}`);
+    const [rows] = await db.query(query).json().collect();
+    return (rows ?? []).map((row)=>normalizeOutputRecordIds({
+            model,
+            data: applyJoinMappings({
+                row,
+                mappings: joinPlan.mappings,
+                ...args
+            }),
+            ...args
+        }));
+};
+export { findMany };

package/dist/betterAuth/server/surrealDbAdapter/methods/findOne.d.ts

@@ -0,0 +1,2 @@
+import type { FindOne } from './types';
+export declare const findOne: <T>({ model, where, select, join, surrealDbProps, ...args }: FindOne) => Promise<T | null>;

package/dist/betterAuth/server/surrealDbAdapter/methods/findOne.js

@@ -0,0 +1,42 @@
+import { Table, raw, surql } from "surrealdb";
+import { getDb } from "../db/index.js";
+import { applyJoinMappings, buildExpression, buildJoinPlan, buildSelectFields, normalizeOutputRecordIds } from "../utils/index.js";
+const findOne = async ({ model, where, select, join, surrealDbProps, ...args })=>{
+    const db = await getDb(surrealDbProps);
+    const table = new Table(model);
+    const expression = buildExpression({
+        model,
+        where,
+        ...args
+    });
+    const joinPlan = buildJoinPlan({
+        model,
+        join,
+        ...args
+    });
+    const fields = buildSelectFields(select, (field)=>args.getFieldName({
+            model,
+            field
+        }));
+    const baseFields = fields.split(', ');
+    const joinFields = joinPlan.selectFields.filter((field)=>!baseFields.includes(field));
+    const finalFields = [
+        ...baseFields,
+        ...joinFields
+    ].join(', ');
+    const query = surql`SELECT ${raw(finalFields)} FROM ${table}`;
+    if (expression) query.append(surql` WHERE ${expression}`);
+    query.append(surql` LIMIT ${1}`);
+    if (joinPlan.fetchFields.size > 0) query.append(surql` FETCH ${raw(Array.from(joinPlan.fetchFields).join(', '))}`);
+    const [rows] = await db.query(query).json().collect();
+    return normalizeOutputRecordIds({
+        model,
+        data: applyJoinMappings({
+            row: rows?.[0] ?? null,
+            mappings: joinPlan.mappings,
+            ...args
+        }),
+        ...args
+    });
+};
+export { findOne };

package/dist/betterAuth/server/surrealDbAdapter/methods/index.d.ts

@@ -0,0 +1,8 @@
+export * from './count';
+export * from './create';
+export * from './delete';
+export * from './deleteMany';
+export * from './findMany';
+export * from './findOne';
+export * from './update';
+export * from './updateMany';

package/dist/betterAuth/server/surrealDbAdapter/methods/index.js

@@ -0,0 +1,8 @@
+export * from "./count.js";
+export * from "./create.js";
+export * from "./delete.js";
+export * from "./deleteMany.js";
+export * from "./findMany.js";
+export * from "./findOne.js";
+export * from "./update.js";
+export * from "./updateMany.js";

package/dist/betterAuth/server/surrealDbAdapter/methods/types.d.ts

@@ -0,0 +1,56 @@
+import type { AdapterFactoryCustomizeAdapterCreator, JoinConfig, Where } from 'better-auth/adapters';
+import type { SurrealDBProps } from '../../../../surrealDB/types';
+type Args = Parameters<AdapterFactoryCustomizeAdapterCreator>[0];
+export type Create<T> = Args & {
+    model: string;
+    data: T;
+    surrealDbProps?: SurrealDBProps;
+};
+export type FindOne = Args & {
+    model: string;
+    where: Required<Where>[];
+    select?: string[];
+    join?: JoinConfig;
+    surrealDbProps?: SurrealDBProps;
+};
+export type SortBy = {
+    field: string;
+    direction: 'asc' | 'desc';
+};
+export type FindMany = Args & {
+    model: string;
+    where?: Required<Where>[];
+    limit: number;
+    offset?: number;
+    sortBy?: SortBy;
+    join?: JoinConfig;
+    surrealDbProps?: SurrealDBProps;
+};
+export type Update<T> = Args & {
+    model: string;
+    where: Required<Where>[];
+    update: T;
+    surrealDbProps?: SurrealDBProps;
+};
+export type UpdateMany = Args & {
+    model: string;
+    where: Required<Where>[];
+    update: Record<string, unknown>;
+    surrealDbProps?: SurrealDBProps;
+};
+export type Delete = Args & {
+    model: string;
+    where: Required<Where>[];
+    surrealDbProps?: SurrealDBProps;
+};
+export type DeleteMany = Args & {
+    model: string;
+    where: Required<Where>[];
+    surrealDbProps?: SurrealDBProps;
+};
+export type Count = Args & {
+    model: string;
+    where?: Required<Where>[];
+    surrealDbProps?: SurrealDBProps;
+};
+export {};

package/dist/betterAuth/server/surrealDbAdapter/methods/update.d.ts

@@ -0,0 +1,2 @@
+import type { Update } from './types';
+export declare const update: <T>({ model, where, update, surrealDbProps, ...args }: Update<T>) => Promise<T | null>;

package/dist/betterAuth/server/surrealDbAdapter/methods/update.js

@@ -0,0 +1,25 @@
+import { Table } from "surrealdb";
+import { getDb } from "../db/index.js";
+import { buildExpression, normalizeOutputRecordIds, normalizeRecordIds } from "../utils/index.js";
+const update_update = async ({ model, where, update, surrealDbProps, ...args })=>{
+    if (!where || 0 === where.length) throw new Error('Update requires a where clause');
+    const db = await getDb(surrealDbProps);
+    const normalized = normalizeRecordIds({
+        model,
+        data: update,
+        ...args
+    });
+    const table = new Table(model);
+    const expression = buildExpression({
+        model,
+        where,
+        ...args
+    });
+    const [updated] = await db.update(table).merge(normalized).where(expression).json();
+    return normalizeOutputRecordIds({
+        model,
+        data: updated ?? null,
+        ...args
+    });
+};
+export { update_update as update };

package/dist/betterAuth/server/surrealDbAdapter/methods/updateMany.d.ts

@@ -0,0 +1,2 @@
+import type { UpdateMany } from './types';
+export declare const updateMany: ({ model, where, update, surrealDbProps, ...args }: UpdateMany) => Promise<number>;

package/dist/betterAuth/server/surrealDbAdapter/methods/updateMany.js

@@ -0,0 +1,21 @@
+import { Table } from "surrealdb";
+import { getDb } from "../db/index.js";
+import { buildExpression, normalizeRecordIds } from "../utils/index.js";
+const updateMany = async ({ model, where, update, surrealDbProps, ...args })=>{
+    if (!where || 0 === where.length) throw new Error('UpdateMany requires a where clause');
+    const db = await getDb(surrealDbProps);
+    const normalized = normalizeRecordIds({
+        model,
+        data: update,
+        ...args
+    });
+    const table = new Table(model);
+    const expression = buildExpression({
+        model,
+        where,
+        ...args
+    });
+    const updated = await db.update(table).merge(normalized).where(expression).json();
+    return updated?.length ?? 0;
+};
+export { updateMany };

package/dist/betterAuth/server/surrealDbAdapter/types.d.ts

@@ -0,0 +1,2 @@
+import type { AdapterFactoryCustomizeAdapterCreator } from 'better-auth/adapters';
+export type Args = Parameters<AdapterFactoryCustomizeAdapterCreator>[0];

package/dist/betterAuth/server/surrealDbAdapter/utils/applyJoinMappings.d.ts

@@ -0,0 +1,2 @@
+import type { ApplyJoinMappings } from './types';
+export declare const applyJoinMappings: ({ row, mappings, ...args }: ApplyJoinMappings) => object | null;

package/dist/betterAuth/server/surrealDbAdapter/utils/applyJoinMappings.js

@@ -0,0 +1,31 @@
+import { normalizeOutputRecordIds } from "./normalizeOutputRecordIds.js";
+const applyJoinMappings = ({ row, mappings, ...args })=>{
+    if (!row || 0 === mappings.length) return row;
+    const normalized = {
+        ...row
+    };
+    for (const mapping of mappings){
+        if (void 0 !== normalized[mapping.modelName]) continue;
+        if (void 0 === normalized[mapping.sourceField]) continue;
+        const sourceValue = normalized[mapping.sourceField];
+        if (Array.isArray(sourceValue)) {
+            normalized[mapping.modelName] = sourceValue.map((item)=>normalizeOutputRecordIds({
+                    model: mapping.modelName,
+                    data: item,
+                    ...args
+                }));
+            continue;
+        }
+        if (sourceValue && 'object' == typeof sourceValue) {
+            normalized[mapping.modelName] = normalizeOutputRecordIds({
+                model: mapping.modelName,
+                data: sourceValue,
+                ...args
+            });
+            continue;
+        }
+        normalized[mapping.modelName] = sourceValue;
+    }
+    return normalized;
+};
+export { applyJoinMappings };

package/dist/betterAuth/server/surrealDbAdapter/utils/buildExpression.d.ts

@@ -0,0 +1,3 @@
+import { type Expr } from 'surrealdb';
+import type { BuildExpression } from './types';
+export declare const buildExpression: ({ model, where, ...args }: BuildExpression) => Expr | undefined;

package/dist/betterAuth/server/surrealDbAdapter/utils/buildExpression.js

@@ -0,0 +1,58 @@
+import { and, contains, eq, gt, gte, inside, lt, lte, or } from "surrealdb";
+import { normalizeWhereValue } from "./normalizeWhereValue.js";
+const buildExpression = ({ model, where, ...args })=>{
+    if (!where || 0 === where.length) return;
+    const opExpression = (clause)=>{
+        const field = clause.field;
+        const value = normalizeWhereValue({
+            model,
+            field,
+            value: clause.value,
+            ...args
+        });
+        const operator = clause.operator ?? 'eq';
+        switch(operator){
+            case 'ne':
+                return {
+                    toSQL: (ctx)=>`${field} != ${ctx.def(value)}`
+                };
+            case 'gt':
+                return gt(field, value);
+            case 'gte':
+                return gte(field, value);
+            case 'lt':
+                return lt(field, value);
+            case 'lte':
+                return lte(field, value);
+            case 'contains':
+                return contains(field, value);
+            case 'starts_with':
+                return {
+                    toSQL: (ctx)=>`string::starts_with(${field}, ${ctx.def(value)})`
+                };
+            case 'ends_with':
+                return {
+                    toSQL: (ctx)=>`string::ends_with(${field}, ${ctx.def(value)})`
+                };
+            case 'in':
+                return inside(field, value);
+            case 'not_in':
+                return {
+                    toSQL: (ctx)=>`${field} NOT IN ${ctx.def(value)}`
+                };
+            default:
+                return eq(field, value);
+        }
+    };
+    let expression;
+    for (const clause of where){
+        const next = opExpression(clause);
+        if (!expression) {
+            expression = next;
+            continue;
+        }
+        expression = 'OR' === clause.connector ? or(expression, next) : and(expression, next);
+    }
+    return expression;
+};
+export { buildExpression };

package/dist/betterAuth/server/surrealDbAdapter/utils/buildJoinPlan.d.ts

@@ -0,0 +1,9 @@
+import type { BuildJoinPlan } from './types';
+export declare const buildJoinPlan: ({ model, join, getDefaultModelName, }: BuildJoinPlan) => {
+    selectFields: string[];
+    fetchFields: Set<string>;
+    mappings: {
+        modelName: string;
+        sourceField: string;
+    }[];
+};

package/dist/betterAuth/server/surrealDbAdapter/utils/buildJoinPlan.js

@@ -0,0 +1,46 @@
+const buildJoinPlan = ({ model, join, getDefaultModelName })=>{
+    const joinFieldsByModel = {
+        user: {
+            account: 'accounts',
+            session: 'sessions'
+        }
+    };
+    const selectFields = [];
+    const fetchFields = new Set();
+    const mappings = [];
+    if (!join || 0 === Object.keys(join).length) return {
+        selectFields,
+        fetchFields,
+        mappings
+    };
+    for (const [joinModel, joinConfig] of Object.entries(join)){
+        const baseModelName = getDefaultModelName(model);
+        const joinModelName = getDefaultModelName(joinModel);
+        const relation = joinConfig.relation ?? 'one-to-many';
+        if ('one-to-one' === relation) {
+            const fromField = joinConfig.on.from;
+            selectFields.push(fromField);
+            fetchFields.add(fromField);
+            mappings.push({
+                modelName: joinModel,
+                sourceField: fromField
+            });
+            continue;
+        }
+        const computedField = joinFieldsByModel[baseModelName]?.[joinModelName];
+        if (computedField) {
+            selectFields.push(computedField);
+            fetchFields.add(computedField);
+            mappings.push({
+                modelName: joinModel,
+                sourceField: computedField
+            });
+        }
+    }
+    return {
+        selectFields,
+        fetchFields,
+        mappings
+    };
+};
+export { buildJoinPlan };

package/dist/betterAuth/server/surrealDbAdapter/utils/buildSelectFields.d.ts

@@ -0,0 +1 @@
+export declare const buildSelectFields: (select: string[] | undefined, mapField: (field: string) => string) => string;

package/dist/betterAuth/server/surrealDbAdapter/utils/buildSelectFields.js

@@ -0,0 +1,5 @@
+const buildSelectFields = (select, mapField)=>{
+    if (!select || 0 === select.length) return '*';
+    return select.map(mapField).join(', ');
+};
+export { buildSelectFields };

package/dist/betterAuth/server/surrealDbAdapter/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './applyJoinMappings';
+export * from './buildExpression';
+export * from './buildJoinPlan';
+export * from './buildSelectFields';
+export * from './normalizeOutputRecordIds';
+export * from './normalizeRecordIds';

package/dist/betterAuth/server/surrealDbAdapter/utils/index.js

@@ -0,0 +1,6 @@
+export * from "./applyJoinMappings.js";
+export * from "./buildExpression.js";
+export * from "./buildJoinPlan.js";
+export * from "./buildSelectFields.js";
+export * from "./normalizeOutputRecordIds.js";
+export * from "./normalizeRecordIds.js";

package/dist/betterAuth/server/surrealDbAdapter/utils/normalizeOutputRecordIds.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizeOutputRecordIds } from './types';
+export declare const normalizeOutputRecordIds: ({ model, data, getDefaultModelName, getDefaultFieldName, getFieldAttributes, }: NormalizeOutputRecordIds) => Record<string, unknown> | null;

package/dist/betterAuth/server/surrealDbAdapter/utils/normalizeOutputRecordIds.js

@@ -0,0 +1,43 @@
+import { RecordId } from "surrealdb";
+const normalizeOutputRecordIds = ({ model, data, getDefaultModelName, getDefaultFieldName, getFieldAttributes })=>{
+    if (!data) return data;
+    const normalized = {
+        ...data
+    };
+    const defaultModelName = getDefaultModelName(model);
+    const stripRecordId = (raw)=>{
+        if (raw instanceof RecordId) return stripRecordId(String(raw));
+        if ('string' != typeof raw) return raw;
+        const separatorIndex = raw.indexOf(':');
+        if (-1 === separatorIndex) return raw;
+        let id = raw.slice(separatorIndex + 1);
+        if (id.startsWith('⟨') && id.endsWith('⟩')) id = id.slice(1, -1);
+        return id;
+    };
+    for (const [field, value] of Object.entries(normalized)){
+        let defaultField;
+        try {
+            defaultField = getDefaultFieldName({
+                model: defaultModelName,
+                field
+            });
+        } catch  {
+            continue;
+        }
+        const applyStrip = (targetValue)=>{
+            if (Array.isArray(targetValue)) return targetValue.map((entry)=>stripRecordId(entry));
+            return stripRecordId(targetValue);
+        };
+        if ('id' === defaultField) {
+            normalized[field] = applyStrip(value);
+            continue;
+        }
+        const fieldAttr = getFieldAttributes({
+            model: defaultModelName,
+            field: defaultField
+        });
+        if (fieldAttr?.references?.field === 'id') normalized[field] = applyStrip(value);
+    }
+    return normalized;
+};
+export { normalizeOutputRecordIds };

package/dist/betterAuth/server/surrealDbAdapter/utils/normalizeRecordIds.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizeRecordIds } from './types';
+export declare const normalizeRecordIds: ({ model, data, getDefaultModelName, getDefaultFieldName, getFieldAttributes, getModelName, }: NormalizeRecordIds) => Record<string, unknown>;

package/dist/betterAuth/server/surrealDbAdapter/utils/normalizeRecordIds.js

@@ -0,0 +1,38 @@
+import { RecordId } from "surrealdb";
+import { deserialize } from "../../../../surrealDB/index.js";
+const normalizeRecordIds = ({ model, data, getDefaultModelName, getDefaultFieldName, getFieldAttributes, getModelName })=>{
+    const normalized = {
+        ...data
+    };
+    const defaultModelName = getDefaultModelName(model);
+    const toRecordId = (target, raw)=>{
+        if (raw instanceof RecordId) return raw;
+        if ('string' == typeof raw) return raw.includes(':') ? deserialize(raw) : new RecordId(target, raw);
+        return raw;
+    };
+    for (const [field, value] of Object.entries(normalized)){
+        let defaultField;
+        try {
+            defaultField = getDefaultFieldName({
+                model: defaultModelName,
+                field
+            });
+        } catch  {
+            continue;
+        }
+        if ('id' === defaultField) continue;
+        const fieldAttr = getFieldAttributes({
+            model: defaultModelName,
+            field: defaultField
+        });
+        if (fieldAttr?.references?.field !== 'id') continue;
+        const targetModel = getModelName(fieldAttr.references.model);
+        if (Array.isArray(value)) {
+            normalized[field] = value.map((entry)=>toRecordId(targetModel, entry));
+            continue;
+        }
+        normalized[field] = toRecordId(targetModel, value);
+    }
+    return normalized;
+};
+export { normalizeRecordIds };

package/dist/betterAuth/server/surrealDbAdapter/utils/normalizeWhereValue.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizeWhereValue } from './types';
+export declare const normalizeWhereValue: ({ model, field, value, getDefaultModelName, getDefaultFieldName, getModelName, getFieldAttributes, }: NormalizeWhereValue) => unknown;

package/dist/betterAuth/server/surrealDbAdapter/utils/normalizeWhereValue.js

@@ -0,0 +1,33 @@
+import { RecordId } from "surrealdb";
+import { deserialize } from "../../../../surrealDB/index.js";
+const normalizeWhereValue = ({ model, field, value, getDefaultModelName, getDefaultFieldName, getModelName, getFieldAttributes })=>{
+    const defaultModelName = getDefaultModelName(model);
+    const toRecordId = (target, raw)=>{
+        if (raw instanceof RecordId) return raw;
+        if ('string' == typeof raw) return raw.includes(':') ? deserialize(raw) : new RecordId(target, raw);
+        return raw;
+    };
+    let defaultField;
+    try {
+        defaultField = getDefaultFieldName({
+            model: defaultModelName,
+            field
+        });
+    } catch  {
+        return value;
+    }
+    if ('id' === defaultField) {
+        const targetModel = getModelName(defaultModelName);
+        if (Array.isArray(value)) return value.map((entry)=>toRecordId(targetModel, entry));
+        return toRecordId(targetModel, value);
+    }
+    const fieldAttr = getFieldAttributes({
+        model: defaultModelName,
+        field: defaultField
+    });
+    if (fieldAttr?.references?.field !== 'id') return value;
+    const targetModel = getModelName(fieldAttr.references.model);
+    if (Array.isArray(value)) return value.map((entry)=>toRecordId(targetModel, entry));
+    return toRecordId(targetModel, value);
+};
+export { normalizeWhereValue };

package/dist/betterAuth/server/surrealDbAdapter/utils/types.d.ts

@@ -0,0 +1,34 @@
+import type { JoinConfig, Where } from 'better-auth/adapters';
+import type { Args } from '../types';
+export type NormalizeRecordIds = Args & {
+    model: string;
+    data: object;
+};
+export type NormalizeOutputRecordIds = Args & {
+    model: string;
+    data: object | null;
+};
+export type NormalizeWhereValue = Args & {
+    model: string;
+    field: string;
+    value: unknown;
+};
+export type BuildExpression = Args & {
+    model: string;
+    where: Required<Where>[] | undefined;
+};
+export type BuildJoinPlan = Args & {
+    model: string;
+    join?: JoinConfig;
+};
+export type ApplyJoinMappings = Args & {
+    row: object | null;
+    mappings: Array<{
+        modelName: string;
+        sourceField: string;
+    }>;
+};
+export type SortBy = {
+    field: string;
+    direction: 'asc' | 'desc';
+};

package/dist/betterAuth/server/types.d.ts

@@ -0,0 +1,8 @@
+export type * from 'better-auth/client/plugins';
+export type * from 'better-auth/minimal';
+export type * from 'better-auth/plugins';
+export type InferUserWithRoles<TInferredUser extends {
+    role?: string | null;
+}, TRoles extends Record<string, unknown>> = Omit<TInferredUser, 'role'> & {
+    role: keyof TRoles;
+};

package/dist/betterAuth/useSessionUser.d.ts

@@ -0,0 +1 @@
+export declare const useSessionUser: <TUser = unknown>() => TUser | undefined;

package/dist/betterAuth/useSessionUser.js

@@ -0,0 +1,8 @@
+import { useRouteContext } from "@tanstack/react-router";
+const useSessionUser = ()=>{
+    const { user } = useRouteContext({
+        from: '__root__'
+    });
+    return user;
+};
+export { useSessionUser };

package/dist/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useMutation';
+export * from './useMutationWithInvalidate';

package/dist/hooks/index.js

@@ -0,0 +1,2 @@
+export * from "./useMutation.js";
+export * from "./useMutationWithInvalidate.js";

package/dist/styles.css

@@ -1,4 +1,4 @@
-.rolder-prompt-input-root {
+.rolder-chat-input-root {
   background-color: light-dark(var(--mantine-color-white), var(--mantine-color-dark-6));
 
   &:focus-within {
@@ -8,13 +8,13 @@
   }
 }
 
-.rolder-prompt-input-textarea {
+.rolder-chat-input-textarea {
   border: 0;
   border-radius: 8px;
   overflow: hidden;
 }
 
-.rolder-prompt-input-file-action-action {
+.rolder-chat-input-file-action-action {
   color: light-dark(var(--mantine-color-gray-7), var(--mantine-color-dark-1));
 
   &[data-disabled] {
@@ -62,11 +62,6 @@
   border-radius: var(--radius);
 }
 
-.rolder-scroll-area-content {
-  width: 100%;
-  height: 100%;
-}
-
 .rolder-scroll-area-scrollbar {
   border-top-right-radius: var(--radius);
   border-bottom-right-radius: var(--radius);

package/dist/surrealDB/deafaultCrud.d.ts

@@ -0,0 +1,2 @@
+export declare const surrealDeleteFn: import("@tanstack/react-start").RequiredFetcher<undefined, import("zod").ZodString, Promise<void>>;
+export declare const surrealUnsubscribeFn: import("@tanstack/react-start").RequiredFetcher<undefined, import("zod").ZodString, Promise<void>>;