@live-state/sync 0.0.6 → 0.0.7-canary-2

package/dist/server.d.cts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { L as LiveObjectAny, W as WhereClause, S as Simplify, I as InferLiveObjectWithRelationalIds, M as MaterializedLiveType, a as Schema, b as IncludeClause, c as InferLiveObject, d as InferInsert, e as InferUpdate, f as Logger, g as LogLevel } from './index-BtsKDfTE.cjs';
+import { L as LiveObjectAny, I as IncludeClause, a as InferLiveObject, W as WhereClause, S as Simplify, b as InferInsert, c as InferUpdate, M as MaterializedLiveType, d as Schema, e as LiveCollectionAny, f as InferLiveCollection, g as InferLiveObjectWithRelationalIds, h as Logger, i as LogLevel } from './index-hO1iQ-VU.cjs';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 import { PostgresPool, Kysely } from 'kysely';
 import { Application } from 'express-ws';
@@ -34,17 +34,191 @@ declare const defaultMutationSchema: z.ZodObject<{
             timestamp: z.ZodNullable<z.ZodOptional<z.ZodString>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    meta: z.ZodOptional<z.ZodObject<{
+        timestamp: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 type DefaultMutation = Omit<z.infer<typeof defaultMutationSchema>, "resourceId"> & {
     resourceId: string;
 };
 
+type ConditionalPromise<T, P extends boolean> = P extends true ? Promise<T> : T;
 type PromiseOrSync<T> = T | Promise<T>;
 
+/** biome-ignore-all lint/suspicious/noExplicitAny: false positive */
+
+declare abstract class Storage implements DataSource {
+    /**
+     * @deprecated Use db.[collection].one(id).get() instead
+     */
+    abstract findOne<T extends LiveObjectAny, TInclude extends IncludeClause<T> | undefined = undefined>(resource: T, id: string, options?: {
+        include?: TInclude;
+    }): Promise<InferLiveObject<T, TInclude> | undefined>;
+    /**
+     * @deprecated Use db.[collection].where({...}).get() instead
+     */
+    abstract find<T extends LiveObjectAny, TInclude extends IncludeClause<T> | undefined = undefined>(resource: T, options?: {
+        where?: WhereClause<T>;
+        include?: TInclude;
+        limit?: number;
+        sort?: {
+            key: string;
+            direction: "asc" | "desc";
+        }[];
+    }): Promise<InferLiveObject<T, TInclude>[]>;
+    /**
+     * @deprecated Use db.[collection].insert({...}) instead
+     */
+    insert<T extends LiveObjectAny>(resource: T, value: Simplify<InferInsert<T>>): Promise<InferLiveObject<T>>;
+    /**
+     * @deprecated Use db.[collection].update(id, {...}) instead
+     */
+    update<T extends LiveObjectAny>(resource: T, resourceId: string, value: InferUpdate<T>): Promise<Partial<InferLiveObject<T>>>;
+    abstract transaction<T>(fn: (opts: {
+        trx: Storage;
+        commit: () => Promise<void>;
+        rollback: () => Promise<void>;
+    }) => Promise<T>): Promise<T>;
+}
+
+/** biome-ignore-all lint/suspicious/noExplicitAny: false positive */
+
+declare class Batcher {
+    private storage;
+    private queue;
+    private scheduled;
+    constructor(storage: Storage);
+    rawFind<T extends LiveObjectAny>({ resource, commonWhere, uniqueWhere, ...rest }: {
+        resource: string;
+        commonWhere?: Record<string, any>;
+        uniqueWhere?: Record<string, any>;
+        include?: Record<string, any>;
+        limit?: number;
+        sort?: {
+            key: string;
+            direction: "asc" | "desc";
+        }[];
+    }): Promise<MaterializedLiveType<T>[]>;
+    private getBatchKey;
+    private processBatch;
+    private executeBatchedRequests;
+}
+
+interface DataSource {
+    get(query: RawQueryRequest, extra?: {
+        context?: any;
+        batcher?: Batcher;
+    }): PromiseOrSync<any[]>;
+}
+
+/** biome-ignore-all lint/complexity/noBannedTypes: <explanation> */
+
+type InferQueryResult<TCollection extends LiveObjectAny, TInclude extends IncludeClause<TCollection>, TSingle extends boolean = false> = TSingle extends true ? Simplify<InferLiveObject<TCollection, TInclude>> | undefined : Simplify<InferLiveObject<TCollection, TInclude>>[];
+declare class QueryBuilder<TCollection extends LiveObjectAny, TInclude extends IncludeClause<TCollection> = {}, TSingle extends boolean = false, TShouldAwait extends boolean = false> {
+    private _collection;
+    private _client;
+    private _where;
+    private _include;
+    private _limit?;
+    private _single?;
+    private _sort?;
+    private _shouldAwait?;
+    private constructor();
+    where(where: WhereClause<TCollection>): QueryBuilder<TCollection, TInclude, TSingle, TShouldAwait>;
+    include<TNewInclude extends IncludeClause<TCollection>>(include: TNewInclude): QueryBuilder<TCollection, TInclude & TNewInclude, TSingle, TShouldAwait>;
+    limit(limit: number): QueryBuilder<TCollection, TInclude, TSingle, TShouldAwait>;
+    one(id: string): QueryBuilder<TCollection, TInclude, true, TShouldAwait>;
+    first(where?: WhereClause<TCollection>): QueryBuilder<TCollection, TInclude, true, TShouldAwait>;
+    orderBy(key: keyof TCollection["fields"], direction?: "asc" | "desc"): QueryBuilder<TCollection, TInclude, TSingle, TShouldAwait>;
+    toJSON(): {
+        resource: string;
+        where: WhereClause<TCollection>;
+        include: TInclude;
+        limit: number | undefined;
+        sort: {
+            key: string;
+            direction: "asc" | "desc";
+        }[] | undefined;
+    };
+    buildQueryRequest(): RawQueryRequest;
+    get(): ConditionalPromise<InferQueryResult<TCollection, TInclude, TSingle>, TShouldAwait>;
+    subscribe(callback: (value: InferQueryResult<TCollection, TInclude, TSingle>) => void): () => void;
+}
+
+/** biome-ignore-all lint/suspicious/noExplicitAny: false positive */
+
+/**
+ * A QueryBuilder with added insert() and update() mutation methods for server-side use.
+ */
+type ServerCollection<T extends LiveCollectionAny> = QueryBuilder<T, {}, false, true> & {
+    /**
+     * Insert a new record into this collection.
+     */
+    insert(value: Simplify<InferInsert<T>>): Promise<InferLiveCollection<T>>;
+    /**
+     * Update an existing record in this collection.
+     */
+    update(id: string, value: InferUpdate<T>): Promise<Partial<InferLiveCollection<T>>>;
+};
+/**
+ * Server database interface that provides collection properties and deprecated methods.
+ * Each collection property (e.g., db.users, db.posts) is a ServerCollection with
+ * QueryBuilder methods plus insert/update mutations.
+ */
+type ServerDB<TSchema extends Schema<any>> = {
+    [K in keyof TSchema]: ServerCollection<TSchema[K]>;
+} & {
+    /**
+     * @deprecated Use db.[collection].one(id).get() instead
+     */
+    findOne: Storage['findOne'];
+    /**
+     * @deprecated Use db.[collection].where({...}).get() instead
+     */
+    find: Storage['find'];
+    /**
+     * @deprecated Use db.[collection].insert({...}) instead
+     */
+    insert: Storage['insert'];
+    /**
+     * @deprecated Use db.[collection].update(id, {...}) instead
+     */
+    update: Storage['update'];
+    /**
+     * Execute operations within a transaction.
+     * The transaction wrapper provides a ServerDB interface for the transaction.
+     */
+    transaction: <T>(fn: (opts: {
+        trx: ServerDB<TSchema>;
+        commit: () => Promise<void>;
+        rollback: () => Promise<void>;
+    }) => Promise<T>) => Promise<T>;
+};
+/**
+ * Creates a ServerDB proxy that wraps a Storage instance with QueryBuilder-based syntax.
+ *
+ * @example
+ * ```typescript
+ * const db = createServerDB(storage, schema);
+ *
+ * // New syntax
+ * const user = await db.users.one(userId).get();
+ * const posts = await db.posts.where({ authorId: userId }).limit(10).get();
+ * await db.users.insert({ id: '...', name: '...' });
+ *
+ * // Deprecated syntax (still works)
+ * const user = await db.findOne(schema.users, userId);
+ * const posts = await db.find(schema.posts, { where: { authorId: userId }, limit: 10 });
+ * ```
+ */
+declare function createServerDB<TSchema extends Schema<any>>(storage: Storage, schema: TSchema): ServerDB<TSchema>;
+
 /** biome-ignore-all lint/suspicious/noExplicitAny: false positive */
 /** biome-ignore-all lint/style/noNonNullAssertion: false positive */
 
-type RouteRecord = Record<string, AnyRoute>;
+type AnyProcedureRoute = ProcedureRoute<Middleware<any>, Record<string, any>, Record<string, any>, any>;
+type AnyRouteOrProcedure = AnyRoute | AnyProcedureRoute;
+type RouteRecord = Record<string, AnyRouteOrProcedure>;
 declare class Router<TRoutes extends RouteRecord> {
     readonly routes: TRoutes;
     readonly hooksRegistry: Map<string, Hooks<any>>;
@@ -54,7 +228,7 @@ declare class Router<TRoutes extends RouteRecord> {
     }): Router<TRoutes>;
     getHooks(resourceName: string): Hooks<any> | undefined;
 }
-declare const router: <TSchema extends Schema<any>, TRoutes extends Record<keyof TSchema, Route<any, any, any>>>(opts: {
+declare const router: <TSchema extends Schema<any>, TRoutes extends Record<keyof TSchema, Route<any, any, any, any, any>> & Record<string, Route<any, any, any, any, any> | ProcedureRoute<any, any, any, any>>>(opts: {
     schema: TSchema;
     routes: TRoutes;
 }) => Router<TRoutes>;
@@ -68,23 +242,53 @@ type MutationResult<TShape extends LiveObjectAny> = {
     acceptedValues: Record<string, any> | null;
 };
 type Mutation<TInputValidator extends StandardSchemaV1<any, any> | never, TOutput> = {
+    _type: "mutation";
     inputValidator: TInputValidator;
     handler: (opts: {
         req: MutationRequest<TInputValidator extends StandardSchemaV1<any, any> ? StandardSchemaV1.InferOutput<TInputValidator> : undefined>;
-        db: Storage;
+        db: ServerDB<any>;
+    }) => TOutput;
+};
+interface QueryProcedureRequest<TInput = any> extends BaseRequest {
+    type: "CUSTOM_QUERY";
+    input: TInput;
+    resource: string;
+    procedure: string;
+}
+type Query<TInputValidator extends StandardSchemaV1<any, any> | never, TOutput> = {
+    _type: "query";
+    inputValidator: TInputValidator;
+    handler: (opts: {
+        req: QueryProcedureRequest<TInputValidator extends StandardSchemaV1<any, any> ? StandardSchemaV1.InferOutput<TInputValidator> : undefined>;
+        db: ServerDB<any>;
     }) => TOutput;
 };
-type MutationCreator = {
+type Procedure<TInputValidator extends StandardSchemaV1<any, any> | never, TOutput> = Mutation<TInputValidator, TOutput> | Query<TInputValidator, TOutput>;
+type QueryCreator<TSchema extends Schema<any> = Schema<any>> = {
+    (): {
+        handler: <TOutput>(handler: (opts: {
+            req: QueryProcedureRequest<undefined>;
+            db: ServerDB<TSchema>;
+        }) => TOutput) => Query<StandardSchemaV1<any, undefined>, TOutput>;
+    };
+    <TInputValidator extends StandardSchemaV1<any, any>>(validator: TInputValidator): {
+        handler: <THandler extends (opts: {
+            req: QueryProcedureRequest<StandardSchemaV1.InferOutput<TInputValidator>>;
+            db: ServerDB<TSchema>;
+        }) => any>(handler: THandler) => Query<TInputValidator, ReturnType<THandler>>;
+    };
+};
+type MutationCreator<TSchema extends Schema<any> = Schema<any>> = {
     (): {
         handler: <TOutput>(handler: (opts: {
             req: MutationRequest<undefined>;
-            db: Storage;
+            db: ServerDB<TSchema>;
         }) => TOutput) => Mutation<StandardSchemaV1<any, undefined>, TOutput>;
     };
     <TInputValidator extends StandardSchemaV1<any, any>>(validator: TInputValidator): {
         handler: <THandler extends (opts: {
             req: MutationRequest<StandardSchemaV1.InferOutput<TInputValidator>>;
-            db: Storage;
+            db: ServerDB<TSchema>;
         }) => any>(handler: THandler) => Mutation<TInputValidator, ReturnType<THandler>>;
     };
 };
@@ -104,23 +308,23 @@ type Authorization<TShape extends LiveObjectAny> = {
         postMutation?: MutationAuthorizationHandler<TShape>;
     };
 };
-type BeforeInsertHook<TShape extends LiveObjectAny> = (opts: {
+type BeforeInsertHook<TShape extends LiveObjectAny, TSchema extends Schema<any> = Schema<any>> = (opts: {
     ctx?: Record<string, any>;
     value: Simplify<InferLiveObjectWithRelationalIds<TShape>> & {
         id: string;
     };
     rawValue: MaterializedLiveType<TShape>;
-    db: Storage;
+    db: ServerDB<TSchema>;
 }) => Promise<MaterializedLiveType<TShape> | void> | MaterializedLiveType<TShape> | void;
-type AfterInsertHook<TShape extends LiveObjectAny> = (opts: {
+type AfterInsertHook<TShape extends LiveObjectAny, TSchema extends Schema<any> = Schema<any>> = (opts: {
     ctx?: Record<string, any>;
     value: Simplify<InferLiveObjectWithRelationalIds<TShape>> & {
         id: string;
     };
     rawValue: MaterializedLiveType<TShape>;
-    db: Storage;
+    db: ServerDB<TSchema>;
 }) => Promise<void> | void;
-type BeforeUpdateHook<TShape extends LiveObjectAny> = (opts: {
+type BeforeUpdateHook<TShape extends LiveObjectAny, TSchema extends Schema<any> = Schema<any>> = (opts: {
     ctx?: Record<string, any>;
     value: Simplify<InferLiveObjectWithRelationalIds<TShape>> & {
         id: string;
@@ -130,9 +334,9 @@ type BeforeUpdateHook<TShape extends LiveObjectAny> = (opts: {
         id: string;
     };
     previousRawValue?: MaterializedLiveType<TShape>;
-    db: Storage;
+    db: ServerDB<TSchema>;
 }) => Promise<MaterializedLiveType<TShape> | void> | MaterializedLiveType<TShape> | void;
-type AfterUpdateHook<TShape extends LiveObjectAny> = (opts: {
+type AfterUpdateHook<TShape extends LiveObjectAny, TSchema extends Schema<any> = Schema<any>> = (opts: {
     ctx?: Record<string, any>;
     value: Simplify<InferLiveObjectWithRelationalIds<TShape>> & {
         id: string;
@@ -142,93 +346,61 @@ type AfterUpdateHook<TShape extends LiveObjectAny> = (opts: {
         id: string;
     };
     previousRawValue?: MaterializedLiveType<TShape>;
-    db: Storage;
+    db: ServerDB<TSchema>;
 }) => Promise<void> | void;
-type Hooks<TShape extends LiveObjectAny> = {
-    beforeInsert?: BeforeInsertHook<TShape>;
-    afterInsert?: AfterInsertHook<TShape>;
-    beforeUpdate?: BeforeUpdateHook<TShape>;
-    afterUpdate?: AfterUpdateHook<TShape>;
+type Hooks<TShape extends LiveObjectAny, TSchema extends Schema<any> = Schema<any>> = {
+    beforeInsert?: BeforeInsertHook<TShape, TSchema>;
+    afterInsert?: AfterInsertHook<TShape, TSchema>;
+    beforeUpdate?: BeforeUpdateHook<TShape, TSchema>;
+    afterUpdate?: AfterUpdateHook<TShape, TSchema>;
 };
-declare class Route<TResourceSchema extends LiveObjectAny, TMiddleware extends Middleware<any>, TCustomMutations extends Record<string, Mutation<any, any>>> {
+declare class Route<TResourceSchema extends LiveObjectAny, TMiddleware extends Middleware<any>, TCustomMutations extends Record<string, Mutation<any, any>>, TCustomQueries extends Record<string, Query<any, any>>, TSchema extends Schema<any> = Schema<any>> {
     readonly resourceSchema: TResourceSchema;
     readonly middlewares: Set<TMiddleware>;
     readonly customMutations: TCustomMutations;
+    readonly customQueries: TCustomQueries;
     readonly authorization?: Authorization<TResourceSchema>;
-    readonly hooks?: Hooks<TResourceSchema>;
-    constructor(resourceSchema: TResourceSchema, customMutations?: TCustomMutations, authorization?: Authorization<TResourceSchema>, hooks?: Hooks<TResourceSchema>);
+    readonly hooks?: Hooks<TResourceSchema, TSchema>;
+    constructor(resourceSchema: TResourceSchema, customMutations?: TCustomMutations, customQueries?: TCustomQueries, authorization?: Authorization<TResourceSchema>, hooks?: Hooks<TResourceSchema, TSchema>);
     use(...middlewares: TMiddleware[]): this;
+    withProcedures<T extends Record<string, Procedure<any, any>>>(procedureFactory: (opts: {
+        mutation: MutationCreator<TSchema>;
+        query: QueryCreator<TSchema>;
+    }) => T): Route<TResourceSchema, TMiddleware, { [K in keyof T as T[K] extends Mutation<any, any> ? K : never]: T[K]; } & Record<string, Mutation<any, any>>, { [K_1 in keyof T as T[K_1] extends Query<any, any> ? K_1 : never]: T[K_1]; } & Record<string, Query<any, any>>, TSchema>;
+    /**
+     * @deprecated Use `withProcedures` instead
+     */
     withMutations<T extends Record<string, Mutation<any, any>>>(mutationFactory: (opts: {
         mutation: typeof mutationCreator;
-    }) => T): Route<TResourceSchema, TMiddleware, T>;
-    withHooks(hooks: Hooks<TResourceSchema>): Route<TResourceSchema, TMiddleware, TCustomMutations>;
+    }) => T): Route<TResourceSchema, TMiddleware, { [K in keyof T as T[K] extends Mutation<any, any> ? K : never]: T[K]; } & Record<string, Mutation<any, any>>, { [K_1 in keyof T as T[K_1] extends Query<any, any> ? K_1 : never]: T[K_1]; } & Record<string, Query<any, any>>, TSchema>;
+    withHooks(hooks: Hooks<TResourceSchema, TSchema>): Route<TResourceSchema, TMiddleware, TCustomMutations, TCustomQueries, TSchema>;
     getAuthorizationClause(req: QueryRequest): WhereClause<TResourceSchema> | undefined | boolean;
     private handleSet;
     private wrapInMiddlewares;
 }
-declare class RouteFactory {
+declare class ProcedureRoute<TMiddleware extends Middleware<any>, TCustomMutations extends Record<string, Mutation<any, any>>, TCustomQueries extends Record<string, Query<any, any>>, TSchema extends Schema<any> = Schema<any>> {
+    readonly resourceSchema: undefined;
+    readonly middlewares: Set<TMiddleware>;
+    readonly customMutations: TCustomMutations;
+    readonly customQueries: TCustomQueries;
+    constructor(customMutations?: TCustomMutations, customQueries?: TCustomQueries);
+    use(...middlewares: TMiddleware[]): this;
+    getAuthorizationClause(): undefined;
+    private wrapInMiddlewares;
+}
+declare class RouteFactory<TSchema extends Schema<any> = Schema<any>> {
     private middlewares;
     private constructor();
-    collectionRoute<T extends LiveObjectAny>(shape: T, authorization?: Authorization<T>): Route<T, Middleware<any>, Record<string, never>>;
-    use(...middlewares: Middleware<any>[]): RouteFactory;
-    static create(): RouteFactory;
+    collectionRoute<T extends LiveObjectAny>(shape: T, authorization?: Authorization<T>): Route<T, Middleware<any>, Record<string, never>, Record<string, never>, TSchema>;
+    withProcedures<T extends Record<string, Procedure<any, any>>>(procedureFactory: (opts: {
+        mutation: MutationCreator<TSchema>;
+        query: QueryCreator<TSchema>;
+    }) => T): ProcedureRoute<Middleware<any>, { [K in keyof T as T[K] extends Mutation<any, any> ? K : never]: T[K]; } & Record<string, Mutation<any, any>>, { [K_1 in keyof T as T[K_1] extends Query<any, any> ? K_1 : never]: T[K_1]; } & Record<string, Query<any, any>>, TSchema>;
+    use(...middlewares: Middleware<any>[]): RouteFactory<TSchema>;
+    static create<TSchema extends Schema<any> = Schema<any>>(): RouteFactory<TSchema>;
 }
 declare const routeFactory: typeof RouteFactory.create;
-type AnyRoute = Route<LiveObjectAny, Middleware<any>, Record<string, any>>;
-
-/** biome-ignore-all lint/suspicious/noExplicitAny: false positive */
-
-declare class Batcher {
-    private storage;
-    private queue;
-    private scheduled;
-    constructor(storage: Storage);
-    rawFind<T extends LiveObjectAny>({ resource, commonWhere, uniqueWhere, ...rest }: {
-        resource: string;
-        commonWhere?: Record<string, any>;
-        uniqueWhere?: Record<string, any>;
-        include?: Record<string, any>;
-        limit?: number;
-        sort?: {
-            key: string;
-            direction: "asc" | "desc";
-        }[];
-    }): Promise<MaterializedLiveType<T>[]>;
-    private getBatchKey;
-    private processBatch;
-    private executeBatchedRequests;
-}
-
-interface DataSource {
-    get(query: RawQueryRequest, extra?: {
-        context?: any;
-        batcher?: Batcher;
-    }): PromiseOrSync<any[]>;
-}
-
-/** biome-ignore-all lint/suspicious/noExplicitAny: false positive */
-
-declare abstract class Storage implements DataSource {
-    abstract findOne<T extends LiveObjectAny, TInclude extends IncludeClause<T> | undefined = undefined>(resource: T, id: string, options?: {
-        include?: TInclude;
-    }): Promise<InferLiveObject<T, TInclude> | undefined>;
-    abstract find<T extends LiveObjectAny, TInclude extends IncludeClause<T> | undefined = undefined>(resource: T, options?: {
-        where?: WhereClause<T>;
-        include?: TInclude;
-        limit?: number;
-        sort?: {
-            key: string;
-            direction: "asc" | "desc";
-        }[];
-    }): Promise<InferLiveObject<T, TInclude>[]>;
-    insert<T extends LiveObjectAny>(resource: T, value: Simplify<InferInsert<T>>): Promise<InferLiveObject<T>>;
-    update<T extends LiveObjectAny>(resource: T, resourceId: string, value: InferUpdate<T>): Promise<Partial<InferLiveObject<T>>>;
-    abstract transaction<T>(fn: (opts: {
-        trx: Storage;
-        commit: () => Promise<void>;
-        rollback: () => Promise<void>;
-    }) => Promise<T>): Promise<T>;
-}
+type AnyRoute = Route<LiveObjectAny, Middleware<any>, Record<string, any>, Record<string, any>, any>;
 
 /** biome-ignore-all lint/suspicious/noExplicitAny: false positive */
 
@@ -301,7 +473,7 @@ interface MutationRequest<TInput = any> extends BaseRequest {
     resourceId?: string;
     procedure: string;
 }
-type Request = QueryRequest | MutationRequest;
+type Request = QueryRequest | MutationRequest | QueryProcedureRequest;
 type ContextProvider = (req: Omit<BaseRequest, "context"> & {
     transport: "HTTP" | "WEBSOCKET";
 }) => Record<string, any>;
@@ -333,10 +505,14 @@ declare class Server<TRouter extends AnyRouter> {
     handleMutation(opts: {
         req: MutationRequest;
     }): Promise<any>;
+    handleCustomQuery(opts: {
+        req: QueryProcedureRequest;
+        subscription?: (mutation: DefaultMutation) => void;
+    }): Promise<any>;
     use(middleware: Middleware<any>): this;
     context(contextProvider: ContextProvider): this;
     private wrapInMiddlewares;
 }
 declare const server: typeof Server.create;
 
-export { type AfterInsertHook, type AfterUpdateHook, type AnyRoute, type AnyRouter, type Authorization, type BaseRequest, type BeforeInsertHook, type BeforeUpdateHook, type ContextProvider, type Hooks, type Middleware, type Mutation, type MutationAuthorizationHandler, type MutationRequest, type MutationResult, type NextFunction, type QueryRequest, type QueryResult, type ReadAuthorizationHandler, type Request, Route, RouteFactory, type RouteRecord, Router, SQLStorage, Server, Storage, expressAdapter, routeFactory, router, server };
+export { type AfterInsertHook, type AfterUpdateHook, type AnyProcedureRoute, type AnyRoute, type AnyRouteOrProcedure, type AnyRouter, type Authorization, type BaseRequest, type BeforeInsertHook, type BeforeUpdateHook, type ContextProvider, type Hooks, type Middleware, type Mutation, type MutationAuthorizationHandler, type MutationRequest, type MutationResult, type NextFunction, type Procedure, ProcedureRoute, type Query, type QueryProcedureRequest, type QueryRequest, type QueryResult, type ReadAuthorizationHandler, type Request, Route, RouteFactory, type RouteRecord, Router, SQLStorage, Server, type ServerCollection, type ServerDB, Storage, createServerDB, expressAdapter, routeFactory, router, server };