remult 2.7.34 → 3.0.0-next.2

package/esm/src/buildRestDataProvider.js

@@ -1,5 +1,5 @@
-import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider.js';
-import { flags } from './remult3/remult3.js';
+import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider-using-fetch.js';
+import { retry } from './data-providers/retry.js';
 export function buildRestDataProvider(provider) {
     if (!provider)
         return new RestDataProviderHttpProviderUsingFetch();
@@ -40,30 +40,6 @@ export class HttpProviderBridgeToRestDataProviderHttpProvider {
         return await retry(() => toPromise(this.http.get(url)));
     }
 }
-export async function retry(what) {
-    let i = 0;
-    while (true) {
-        try {
-            return await what();
-        }
-        catch (err) {
-            if ((err.message?.startsWith('Error occurred while trying to proxy') ||
-                err.message?.startsWith('Error occured while trying to proxy') ||
-                err.message?.includes('http proxy error') ||
-                err.message?.startsWith('Gateway Timeout') ||
-                err.status == 500) &&
-                i++ < flags.error500RetryCount) {
-                await new Promise((res, req) => {
-                    setTimeout(() => {
-                        res({});
-                    }, 500);
-                });
-                continue;
-            }
-            throw err;
-        }
-    }
-}
 export function toPromise(p) {
     let r;
     if (p['toPromise'] !== undefined) {

package/esm/src/context.js

@@ -64,14 +64,16 @@ export class Remult {
      * @param dataProvider - an optional alternative data provider to use. Useful for writing to offline storage or an alternative data provider
      */
     repo = (entity, dataProvider) => {
+        const info = createOldEntity(entity, this);
         if (dataProvider === undefined)
-            dataProvider = this.dataProvider;
+            dataProvider =
+                info?.options?.dataProvider?.(this.dataProvider) ?? this.dataProvider;
         let dpCache = this.repCache.get(dataProvider);
         if (!dpCache)
             this.repCache.set(dataProvider, (dpCache = new Map()));
         let r = dpCache.get(entity);
         if (!r) {
-            dpCache.set(entity, (r = new RepositoryImplementation(entity, this, dataProvider, createOldEntity(entity, this))));
+            dpCache.set(entity, (r = new RepositoryImplementation(entity, this, dataProvider, info)));
             verifyFieldRelationInfo(r, this, dataProvider);
         }
         return r;

package/esm/src/data-providers/rest-data-provider-using-fetch.js

@@ -0,0 +1,78 @@
+import { retry } from './retry.js';
+export class RestDataProviderHttpProviderUsingFetch {
+    fetch;
+    constructor(fetch) {
+        this.fetch = fetch;
+    }
+    async get(url) {
+        return await retry(async () => this.myFetch(url).then((r) => {
+            return r;
+        }));
+    }
+    put(url, data) {
+        return this.myFetch(url, {
+            method: 'put',
+            body: JSON.stringify(data),
+        });
+    }
+    delete(url) {
+        return this.myFetch(url, { method: 'delete' });
+    }
+    async post(url, data) {
+        return await retry(() => this.myFetch(url, {
+            method: 'post',
+            body: JSON.stringify(data),
+        }));
+    }
+    myFetch(url, options) {
+        const headers = {};
+        if (options?.body)
+            headers['Content-type'] = 'application/json';
+        if (typeof window !== 'undefined' &&
+            typeof window.document !== 'undefined' &&
+            typeof (window.document.cookie !== 'undefined'))
+            for (const cookie of window.document.cookie.split(';')) {
+                if (cookie.trim().startsWith('XSRF-TOKEN=')) {
+                    headers['X-XSRF-TOKEN'] = cookie.split('=')[1];
+                }
+            }
+        return (this.fetch || fetch)(url, {
+            credentials: 'include',
+            method: options?.method,
+            body: options?.body,
+            headers,
+        })
+            .then((response) => {
+            return onSuccess(response);
+        })
+            .catch(async (error) => {
+            let r = await error;
+            throw r;
+        });
+    }
+}
+function onSuccess(response) {
+    if (response.status == 204)
+        return;
+    if (response.status >= 200 && response.status < 300)
+        return response.json();
+    else {
+        throw response
+            .json()
+            .then((x) => {
+            return {
+                ...x,
+                message: x.message || response.statusText,
+                url: response.url,
+                status: response.status,
+            };
+        })
+            .catch(() => {
+            throw {
+                message: response.statusText,
+                url: response.url,
+                status: response.status,
+            };
+        });
+    }
+}

package/esm/src/data-providers/rest-data-provider.js

@@ -1,5 +1,5 @@
 import { UrlBuilder } from '../../urlBuilder.js';
-import { buildRestDataProvider, retry } from '../buildRestDataProvider.js';
+import { buildRestDataProvider } from '../buildRestDataProvider.js';
 import { customUrlToken, Filter } from '../filter/filter-interfaces.js';
 import { getRelationFieldInfo } from '../remult3/relationInfoMember.js';
 import { remultStatic } from '../remult-static.js';
@@ -284,83 +284,6 @@ export class RestEntityDataProvider {
             .then((y) => y.map((y) => this.translateFromJson(y)));
     }
 }
-export class RestDataProviderHttpProviderUsingFetch {
-    fetch;
-    constructor(fetch) {
-        this.fetch = fetch;
-    }
-    async get(url) {
-        return await retry(async () => this.myFetch(url).then((r) => {
-            return r;
-        }));
-    }
-    put(url, data) {
-        return this.myFetch(url, {
-            method: 'put',
-            body: JSON.stringify(data),
-        });
-    }
-    delete(url) {
-        return this.myFetch(url, { method: 'delete' });
-    }
-    async post(url, data) {
-        return await retry(() => this.myFetch(url, {
-            method: 'post',
-            body: JSON.stringify(data),
-        }));
-    }
-    myFetch(url, options) {
-        const headers = {};
-        if (options?.body)
-            headers['Content-type'] = 'application/json';
-        if (typeof window !== 'undefined' &&
-            typeof window.document !== 'undefined' &&
-            typeof (window.document.cookie !== 'undefined'))
-            for (const cookie of window.document.cookie.split(';')) {
-                if (cookie.trim().startsWith('XSRF-TOKEN=')) {
-                    headers['X-XSRF-TOKEN'] = cookie.split('=')[1];
-                }
-            }
-        return (this.fetch || fetch)(url, {
-            credentials: 'include',
-            method: options?.method,
-            body: options?.body,
-            headers,
-        })
-            .then((response) => {
-            return onSuccess(response);
-        })
-            .catch(async (error) => {
-            let r = await error;
-            throw r;
-        });
-    }
-}
-function onSuccess(response) {
-    if (response.status == 204)
-        return;
-    if (response.status >= 200 && response.status < 300)
-        return response.json();
-    else {
-        throw response
-            .json()
-            .then((x) => {
-            return {
-                ...x,
-                message: x.message || response.statusText,
-                url: response.url,
-                status: response.status,
-            };
-        })
-            .catch(() => {
-            throw {
-                message: response.statusText,
-                url: response.url,
-                status: response.status,
-            };
-        });
-    }
-}
 export function addFilterToUrlAndReturnTrueIfSuccessful(filter, url) {
     for (const key in filter) {
         if (Object.prototype.hasOwnProperty.call(filter, key)) {

package/esm/src/data-providers/retry.js

@@ -0,0 +1,25 @@
+import { flags } from '../remult3/remult3.js';
+export async function retry(what) {
+    let i = 0;
+    while (true) {
+        try {
+            return await what();
+        }
+        catch (err) {
+            if ((err.message?.startsWith('Error occurred while trying to proxy') ||
+                err.message?.startsWith('Error occured while trying to proxy') ||
+                err.message?.includes('http proxy error') ||
+                err.message?.startsWith('Gateway Timeout') ||
+                err.status == 500) &&
+                i++ < flags.error500RetryCount) {
+                await new Promise((res, req) => {
+                    setTimeout(() => {
+                        res({});
+                    }, 500);
+                });
+                continue;
+            }
+            throw err;
+        }
+    }
+}

package/esm/src/filter/entityDbName.js

@@ -0,0 +1,18 @@
+export async function entityDbName(metadata, wrapIdentifier = (x) => x) {
+    if (metadata.options.sqlExpression) {
+        if (typeof metadata.options.sqlExpression === 'string')
+            return metadata.options.sqlExpression;
+        else if (typeof metadata.options.sqlExpression === 'function') {
+            const prev = metadata.options.sqlExpression;
+            try {
+                metadata.options.sqlExpression =
+                    "recursive sqlExpression call for entity '" + metadata.key + "'. ";
+                return await prev(metadata);
+            }
+            finally {
+                metadata.options.sqlExpression = prev;
+            }
+        }
+    }
+    return wrapIdentifier(metadata.dbName);
+}

package/esm/src/filter/fieldDbName.js

@@ -0,0 +1,40 @@
+import { getRelationFieldInfo } from '../remult3/relationInfoMember.js';
+const sqlExpressionInProgressKey = Symbol.for(`sqlExpressionInProgressKey`);
+export async function fieldDbName(f, meta, wrapIdentifier = (x) => x, forceSqlExpression = false) {
+    try {
+        if (f.options.sqlExpression) {
+            let result;
+            if (typeof f.options.sqlExpression === 'function') {
+                if (f[sqlExpressionInProgressKey] && !forceSqlExpression) {
+                    return "recursive sqlExpression call for field '" + f.key + "'. \0";
+                }
+                try {
+                    ;
+                    f[sqlExpressionInProgressKey] = true;
+                    result = await f.options.sqlExpression(meta);
+                    if (!result.includes('\0'))
+                        f.options.sqlExpression = () => result;
+                }
+                finally {
+                    delete f[sqlExpressionInProgressKey];
+                }
+            }
+            else
+                result = f.options.sqlExpression;
+            if (!result)
+                return f.dbName;
+            return result;
+        }
+        const rel = getRelationFieldInfo(f);
+        let field = rel?.type === 'toOne' &&
+            f.options.field;
+        if (field) {
+            let fInfo = meta.fields.find(field);
+            if (fInfo)
+                return fieldDbName(fInfo, meta, wrapIdentifier, forceSqlExpression);
+        }
+        return wrapIdentifier(f.dbName);
+    }
+    finally {
+    }
+}

package/esm/src/filter/filter-consumer-bridge-to-sql-request.js

@@ -1,7 +1,8 @@
 import { SqlDatabase } from '../data-providers/sql-database.js';
 import { remult } from '../remult-proxy.js';
 import { getEntityMetadata } from '../remult3/RepositoryImplementation.js';
-import { getRelationFieldInfo } from '../remult3/relationInfoMember.js';
+import { entityDbName } from './entityDbName.js';
+import { fieldDbName } from './fieldDbName.js';
 export class FilterConsumerBridgeToSqlRequest {
     r;
     nameProvider;
@@ -260,60 +261,3 @@ async function internalDbNamesOf(repo, wrapIdentifierOrOptions, forceSqlExpressi
     }
     return result;
 }
-export async function entityDbName(metadata, wrapIdentifier = (x) => x) {
-    if (metadata.options.sqlExpression) {
-        if (typeof metadata.options.sqlExpression === 'string')
-            return metadata.options.sqlExpression;
-        else if (typeof metadata.options.sqlExpression === 'function') {
-            const prev = metadata.options.sqlExpression;
-            try {
-                metadata.options.sqlExpression =
-                    "recursive sqlExpression call for entity '" + metadata.key + "'. ";
-                return await prev(metadata);
-            }
-            finally {
-                metadata.options.sqlExpression = prev;
-            }
-        }
-    }
-    return wrapIdentifier(metadata.dbName);
-}
-const sqlExpressionInProgressKey = Symbol.for(`sqlExpressionInProgressKey`);
-export async function fieldDbName(f, meta, wrapIdentifier = (x) => x, forceSqlExpression = false) {
-    try {
-        if (f.options.sqlExpression) {
-            let result;
-            if (typeof f.options.sqlExpression === 'function') {
-                if (f[sqlExpressionInProgressKey] && !forceSqlExpression) {
-                    return "recursive sqlExpression call for field '" + f.key + "'. \0";
-                }
-                try {
-                    ;
-                    f[sqlExpressionInProgressKey] = true;
-                    result = await f.options.sqlExpression(meta);
-                    if (!result.includes('\0'))
-                        f.options.sqlExpression = () => result;
-                }
-                finally {
-                    delete f[sqlExpressionInProgressKey];
-                }
-            }
-            else
-                result = f.options.sqlExpression;
-            if (!result)
-                return f.dbName;
-            return result;
-        }
-        const rel = getRelationFieldInfo(f);
-        let field = rel?.type === 'toOne' &&
-            f.options.field;
-        if (field) {
-            let fInfo = meta.fields.find(field);
-            if (fInfo)
-                return fieldDbName(fInfo, meta, wrapIdentifier, forceSqlExpression);
-        }
-        return wrapIdentifier(f.dbName);
-    }
-    finally {
-    }
-}

package/esm/src/remult3/RepositoryImplementation.js

@@ -14,7 +14,8 @@ import { __updateEntityBasedOnWhere } from './__updateEntityBasedOnWhere.js';
 import { getRelationFieldInfo, } from './relationInfoMember.js';
 import { RelationLoader } from './relation-loader.js';
 import { getInternalKey, } from './repository-internals.js';
-import { entityDbName, fieldDbName, } from '../filter/filter-consumer-bridge-to-sql-request.js';
+import { entityDbName } from '../filter/entityDbName.js';
+import { fieldDbName } from '../filter/fieldDbName.js';
 import { remultStatic } from '../remult-static.js';
 import { Validators } from '../validators.js';
 import { addValidator } from './addValidator.js';

package/esm/src/validators.js

@@ -1,4 +1,4 @@
-import { getRelationFieldInfo } from '../internals.js';
+import { getRelationFieldInfo } from '../src/remult3/relationInfoMember.js';
 /**
  * Class containing various field validators.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "2.7.34",
+    "version": "3.0.0-next.2",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {

package/remult-express.d.ts

@@ -1,9 +1,10 @@
 import * as express from 'express';
 import type { RemultServer, RemultServerCore, RemultServerOptions } from './server/remult-api-server.js';
-export declare function remultExpress(options?: RemultServerOptions<express.Request> & {
+export declare function remultApi(options?: RemultServerOptions<express.Request> & {
     bodyParser?: boolean;
     bodySizeLimit?: string;
-}): RemultExpressServer;
-export type RemultExpressServer = express.RequestHandler & RemultServerCore<express.Request> & {
+}): remultApiServer;
+export type remultApiServer = express.RequestHandler & RemultServerCore<express.Request> & {
     withRemult: (req: express.Request, res: express.Response, next: VoidFunction) => void;
 } & Pick<RemultServer<express.Request>, 'withRemultAsync'>;
+export declare const remultExpress: typeof remultApi;

package/remult-express.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.remultExpress = remultExpress;
+exports.remultExpress = void 0;
+exports.remultApi = remultApi;
 var tslib_1 = require("tslib");
 var express = tslib_1.__importStar(require("express"));
 var index_js_1 = require("./server/index.js");
-function remultExpress(options) {
+function remultApi(options) {
     var _this = this;
     var app = express.Router();
     if (!options) {
@@ -33,3 +34,5 @@ function remultExpress(options) {
         },
     });
 }
+// @deprecated use remultApi instead
+exports.remultExpress = remultApi;

package/remult-fastify.d.ts

@@ -1,6 +1,7 @@
 import type { FastifyPluginCallback, FastifyRequest } from 'fastify';
 import type { RemultServerCore, RemultServerOptions, RemultServer } from './server/remult-api-server.js';
-export declare function remultFastify(options: RemultServerOptions<FastifyRequest>): RemultFastifyServer;
+export declare function remultApi(options: RemultServerOptions<FastifyRequest>): RemultFastifyServer;
 export type RemultFastifyServer = FastifyPluginCallback & RemultServerCore<FastifyRequest> & {
     withRemult: RemultServer<FastifyRequest>['withRemultAsync'];
 };
+export declare const remultFastify: typeof remultApi;

package/remult-fastify.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.remultFastify = remultFastify;
+exports.remultFastify = void 0;
+exports.remultApi = remultApi;
 var tslib_1 = require("tslib");
 var index_js_1 = require("./server/index.js");
-function remultFastify(options) {
+function remultApi(options) {
     var _this = this;
     function fastifyHandler(handler) {
         var response = function (req, res) {
@@ -81,3 +82,5 @@ function remultFastify(options) {
         },
     });
 }
+// @deprecated use remultApi instead
+exports.remultFastify = remultApi;

package/remult-hapi.d.ts

@@ -1,6 +1,7 @@
 import type { Request, Plugin } from '@hapi/hapi';
 import { type RemultServerCore, type RemultServerOptions, type RemultServer } from './server/index.js';
-export declare function remultHapi(options: RemultServerOptions<Request>): RemultHapiServer;
+export declare function remultApi(options: RemultServerOptions<Request>): RemultHapiServer;
 export type RemultHapiServer = Plugin<any, any> & RemultServerCore<Request> & {
     withRemult: RemultServer<Request>['withRemultAsync'];
 };
+export declare const remultHapi: typeof remultApi;

package/remult-hapi.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.remultHapi = remultHapi;
+exports.remultHapi = void 0;
+exports.remultApi = remultApi;
 var tslib_1 = require("tslib");
 var index_js_1 = require("./server/index.js");
 var stream_1 = require("stream");
-function remultHapi(options) {
+function remultApi(options) {
     var _this = this;
     var api = (0, index_js_1.createRemultServer)(options, {
         buildGenericRequestInfo: function (req) { return ({
@@ -125,3 +126,5 @@ function remultHapi(options) {
         },
     });
 }
+// @deprecated use remultApi instead
+exports.remultHapi = remultApi;

package/remult-hono.d.ts

@@ -1,7 +1,8 @@
 import { type Context, type Env, Hono } from 'hono';
 import type { BlankInput } from 'hono/types';
 import { type RemultServerOptions, type RemultServerCore } from './server/index.js';
-export declare function remultHono(options: RemultServerOptions<Context<Env, '', BlankInput>>): RemultHonoServer;
+export declare function remultApi(options: RemultServerOptions<Context<Env, '', BlankInput>>): RemultHonoServer;
 export type RemultHonoServer = Hono & RemultServerCore<Context<Env, '', BlankInput>> & {
     withRemult: <T>(c: Context<Env, '', BlankInput>, what: () => Promise<T>) => Promise<T>;
 };
+export declare const remultHono: typeof remultApi;

package/remult-hono.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.remultHono = remultHono;
+exports.remultHono = void 0;
+exports.remultApi = remultApi;
 var tslib_1 = require("tslib");
 var hono_1 = require("hono");
 var streaming_1 = require("hono/streaming");
 var index_js_1 = require("./server/index.js");
-function remultHono(options) {
+function remultApi(options) {
     var _this = this;
     var app = new hono_1.Hono();
     var api = (0, index_js_1.createRemultServer)(options, {
@@ -113,3 +114,5 @@ function remultHono(options) {
         }); }); },
     });
 }
+// @deprecated use remultApi instead
+exports.remultHono = remultApi;

package/remult-next.d.ts

@@ -15,7 +15,7 @@ export type RemultNextServer = RemultServerCore<NextApiRequest> & NextApiHandler
      */
     handle<T>(handler: NextApiHandler<T>): NextApiHandler<T>;
 };
-export declare function remultNextApp(options?: RemultServerOptions<Request>): RemultNextAppServer;
+export declare function remultApi(options?: RemultServerOptions<Request>): RemultNextAppServer;
 export type RemultNextAppServer = RemultServerCore<Request> & {
     GET: (req: Request) => Promise<Response | undefined>;
     PUT: (req: Request) => Promise<Response | undefined>;
@@ -23,3 +23,4 @@ export type RemultNextAppServer = RemultServerCore<Request> & {
     DELETE: (req: Request) => Promise<Response | undefined>;
     withRemult<T>(what: () => Promise<T>): Promise<T>;
 };
+export declare const remultNextApp: typeof remultApi;

package/remult-next.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.remultNextApp = void 0;
 exports.remultNext = remultNext;
-exports.remultNextApp = remultNextApp;
+exports.remultApi = remultApi;
 var tslib_1 = require("tslib");
 var index_js_1 = require("./server/index.js");
 function remultNext(options) {
@@ -78,7 +79,7 @@ function remultNext(options) {
     });
 }
 var encoder = new TextEncoder();
-function remultNextApp(options) {
+function remultApi(options) {
     var _this = this;
     var result = (0, index_js_1.createRemultServer)(options, {
         getRequestBody: function (req) { return req.json(); },
@@ -183,3 +184,4 @@ function remultNextApp(options) {
         },
     };
 }
+exports.remultNextApp = remultApi;

package/remult-nuxt.d.ts

@@ -1,6 +1,7 @@
 import type { H3Event } from 'h3';
 import type { RemultServerCore, RemultServerOptions, RemultServer } from './server/index.js';
-export declare function remultNuxt(options: RemultServerOptions<H3Event>): RemultNuxtServer;
+export declare function remultApi(options: RemultServerOptions<H3Event>): RemultNuxtServer;
 export type RemultNuxtServer = RemultServerCore<H3Event> & ((event: H3Event) => Promise<any>) & {
     withRemult: RemultServer<H3Event>['withRemultAsync'];
 };
+export declare const remultNuxt: typeof remultApi;

package/remult-nuxt.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.remultNuxt = remultNuxt;
+exports.remultNuxt = void 0;
+exports.remultApi = remultApi;
 var tslib_1 = require("tslib");
 var h3_1 = require("h3");
 var index_js_1 = require("./server/index.js");
-function remultNuxt(options) {
+function remultApi(options) {
     var _this = this;
     var result = (0, index_js_1.createRemultServer)(options, {
         buildGenericRequestInfo: function (event) {
@@ -76,3 +77,4 @@ function remultNuxt(options) {
         },
     });
 }
+exports.remultNuxt = remultApi;

package/remult-solid-start.d.ts

@@ -1,6 +1,6 @@
 import { type RequestEvent } from 'solid-js/web';
 import type { RemultServerCore, RemultServerOptions } from './server/index.js';
-export declare function remultSolidStart(options: RemultServerOptions<RequestEvent>): RemultSolidStartServer;
+export declare function remultApi(options: RemultServerOptions<RequestEvent>): RemultSolidStartServer;
 type RequestHandler = (event: RequestEvent) => Promise<Response>;
 export type RemultSolidStartServer = RemultServerCore<RequestEvent> & {
     withRemult<T>(what: () => Promise<T>): Promise<T>;
@@ -9,4 +9,5 @@ export type RemultSolidStartServer = RemultServerCore<RequestEvent> & {
     POST: RequestHandler;
     DELETE: RequestHandler;
 };
+export declare const remultSolidStart: typeof remultApi;
 export {};

package/remult-solid-start.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.remultSolidStart = remultSolidStart;
+exports.remultSolidStart = void 0;
+exports.remultApi = remultApi;
 var tslib_1 = require("tslib");
 var web_1 = require("solid-js/web");
 var index_js_1 = require("./server/index.js");
-function remultSolidStart(options) {
+function remultApi(options) {
     var _this = this;
     var result = (0, index_js_1.createRemultServer)(options, {
         buildGenericRequestInfo: function (event) { return ({
@@ -131,3 +132,4 @@ function remultSolidStart(options) {
         DELETE: serverHandler,
     });
 }
+exports.remultSolidStart = remultApi;

package/remult-sveltekit.d.ts

@@ -1,6 +1,6 @@
 import type { Handle, RequestEvent, RequestHandler } from '@sveltejs/kit';
 import type { RemultServerCore, RemultServerOptions, RemultServer } from './server/index.js';
-export declare function remultSveltekit(options: RemultServerOptions<RequestEvent>): RemultSveltekitServer;
+export declare function remultApi(options: RemultServerOptions<RequestEvent>): RemultSveltekitServer;
 export type RemultSveltekitServer = RemultServerCore<RequestEvent> & Handle & {
     withRemult: RemultServer<RequestEvent>['withRemultAsync'];
     GET: RequestHandler;
@@ -8,3 +8,4 @@ export type RemultSveltekitServer = RemultServerCore<RequestEvent> & Handle & {
     POST: RequestHandler;
     DELETE: RequestHandler;
 };
+export declare const remultSveltekit: typeof remultApi;