@cequrebackends/cequre-ts 0.11.4

package/dist/shared/core/types.d.ts

@@ -0,0 +1,304 @@
+import type { CequreRequestContext } from "../main/access";
+export interface CequreAST {
+    collections: CollectionConfig[];
+    globals?: CollectionConfig[];
+    core?: {
+        api?: {
+            prefix?: string;
+            version?: string;
+            deprecatedVersions?: string[];
+            sunsetDate?: string;
+            maxBodyBytes?: number;
+            requestTimeoutMs?: number;
+            trustedProxies?: string[];
+            docs?: {
+                enabled?: boolean;
+                authRequired?: boolean;
+            };
+        };
+    };
+    adminUI?: {
+        enabled?: boolean;
+        user?: string;
+    };
+    migrate?: {
+        dropOrphan?: boolean;
+    };
+    security?: {
+        auth?: {
+            strategies?: string[];
+            jwt?: {
+                accessTokenExpiry?: string;
+                refreshTokenExpiry?: string;
+                cookies?: {
+                    name?: string;
+                    timeout?: string;
+                    domain?: string;
+                    secure?: boolean;
+                    httpOnly?: boolean;
+                    sameSite?: "lax" | "strict" | "none";
+                    refreshToken?: boolean;
+                };
+            };
+            apiKey?: {
+                header?: string;
+                enabled?: boolean;
+            };
+            passwordPolicy?: {
+                minLength?: number;
+                requireUppercase?: boolean;
+                requireNumber?: boolean;
+            };
+            lockout?: {
+                maxAttempts?: number;
+                durationMinutes?: number;
+            };
+            mfa?: {
+                enabled?: boolean;
+                issuer?: string;
+                enforceForRoles?: string[];
+                backupCodeCount?: number;
+            };
+        };
+        tls?: {
+            cert?: string;
+            key?: string;
+            passphrase?: string;
+            serverName?: string;
+        };
+        cors?: {
+            origin?: string[];
+            credentials?: boolean;
+        };
+        rateLimit?: {
+            read?: {
+                max?: number;
+                window?: string;
+            };
+            write?: {
+                max?: number;
+                window?: string;
+            };
+            login?: {
+                max?: number;
+                window?: string;
+            };
+        };
+        headers?: {
+            enabled?: boolean;
+            contentSecurityPolicy?: string | false;
+        };
+        audit?: {
+            enabled?: boolean;
+            secret?: string;
+            retentionDays?: number;
+        };
+        secrets?: {
+            enabled?: boolean;
+            encryptionKey?: string;
+        };
+        csrfTrustedOrigins?: string[];
+    };
+    monitoring?: {
+        enabled?: boolean;
+        apiKey?: string;
+        healthCheck?: {
+            enabled?: boolean;
+            path?: string;
+            requiresAuth?: boolean;
+        };
+        requestId?: {
+            enabled?: boolean;
+        };
+    };
+    email?: {
+        from?: string;
+        appName?: string;
+        resetTokenExpiryMinutes?: number;
+        resetPasswordUrl?: string;
+        verifyEmailUrl?: string;
+    };
+}
+export interface CollectionConfig {
+    slug: string;
+    hidden?: boolean;
+    auth?: boolean;
+    realtime?: {
+        secure?: boolean;
+        ws?: boolean | string[];
+        sse?: boolean | string[];
+        durableStream?: boolean | string[];
+    };
+    cache?: {
+        ttl?: string | number;
+        strategy?: "stale-while-revalidate" | string;
+    };
+    fields: FieldConfig[];
+}
+export interface FieldConfig {
+    name: string;
+    type: string;
+    unique?: boolean;
+    optional?: boolean;
+    hidden?: boolean;
+    omit?: boolean;
+    default?: any;
+    target?: string;
+    on?: string;
+    values?: string[];
+    options?: string[];
+    encrypt?: boolean;
+    readRoles?: string[];
+    writeRoles?: string[];
+    saveToJWT?: boolean;
+    searchable?: boolean;
+    fields?: FieldConfig[];
+    isArray?: boolean;
+}
+export interface UploadedFile {
+    filename: string;
+    originalName: string;
+    mimetype: string;
+    size: number;
+    url: string;
+}
+export interface StorageProvider {
+    saveFile(file: File, options?: {
+        filename?: string;
+    }): Promise<UploadedFile>;
+    deleteFile(filename: string): Promise<void>;
+    initMultipartUpload?(options: {
+        filename: string;
+        mimetype: string;
+        size: number;
+    }): Promise<{
+        uploadId: string;
+        filename: string;
+        parts?: {
+            partNumber: number;
+            url: string;
+        }[];
+    }>;
+    completeMultipartUpload?(uploadId: string, filename: string, parts: {
+        partNumber: number;
+        etag?: string;
+    }[]): Promise<UploadedFile>;
+    getFileUrl?(filename: string): Promise<string | undefined>;
+}
+export interface CacheStore {
+    get(key: string): Promise<any | null>;
+    set(key: string, value: any, ttlSeconds?: number): Promise<void>;
+    del(...keys: string[]): Promise<number>;
+    close(): void;
+}
+export type PluginCompilePhase = "request.start" | "beforeHandler" | "afterHandler" | "request.completed" | "request.error";
+export interface CompileVars {
+    [key: string]: string;
+}
+export interface AOTCompileContext {
+    phase: PluginCompilePhase;
+    vars: CompileVars;
+    state: Record<string, any>;
+}
+export interface CequrePlugin {
+    name: string;
+    runsBefore?: string[];
+    runsAfter?: string[];
+    onInit?: (app: any) => void | Promise<void>;
+    onCompile?: (ctx: AOTCompileContext) => string | undefined;
+    preRequest?: (request: Request) => void | Response | Promise<void | Response>;
+    beforeRequest?: (ctx: CequreRequestContext) => void | Promise<void>;
+    afterRequest?: (ctx: CequreRequestContext, response: Response) => void | Promise<void>;
+    onError?: (ctx: CequreRequestContext, error: any) => Response | void | Promise<Response | void>;
+    onDestroy?: () => void | Promise<void>;
+}
+export interface CequreEmailSendOptions {
+    from?: string;
+    to?: string;
+    cc?: string;
+    bcc?: string;
+    replyTo?: string;
+    subject?: string;
+    text?: string;
+    html?: string;
+}
+export interface CequreEmailTransport {
+    send(options: CequreEmailSendOptions): Promise<{
+        messageId: string;
+    }>;
+    verify(): Promise<boolean>;
+}
+export interface EmailTemplates {
+    welcome?: (data: {
+        to: string;
+        appName: string;
+    }) => {
+        subject?: string;
+        html: string;
+        text?: string;
+    };
+    forgotPassword?: (data: {
+        to: string;
+        resetUrl: string;
+        appName: string;
+        expiresInMinutes: number;
+    }) => {
+        subject?: string;
+        html: string;
+        text?: string;
+    };
+    passwordResetSuccess?: (data: {
+        to: string;
+        appName: string;
+    }) => {
+        subject?: string;
+        html: string;
+        text?: string;
+    };
+    verifyEmail?: (data: {
+        to: string;
+        verifyUrl: string;
+        appName: string;
+    }) => {
+        subject?: string;
+        html: string;
+        text?: string;
+    };
+}
+export interface EmailConfig {
+    from?: string;
+    appName?: string;
+    resetTokenExpiryMinutes?: number;
+    resetPasswordUrl?: string;
+    verifyEmailUrl?: string;
+    transport?: CequreEmailTransport;
+    templates?: EmailTemplates;
+}
+export interface CequreServerConfig {
+    port?: number;
+    hostname?: string;
+    fetch: (req: Request, server?: any) => Promise<Response> | Response;
+    tls?: any;
+    maxRequestBodySize?: number;
+    routes?: Record<string, any>;
+    websocket?: any;
+}
+export interface ServerProvider {
+    start(config: CequreServerConfig): void | any;
+    stop?(): Promise<void>;
+}
+export interface CronProvider {
+    registerJob(name: string, cronExpression: string, handler: () => void | Promise<void>): void;
+    startAll(): void;
+    stopAll(): void;
+    list?(): Promise<string[]> | string[];
+    stop?(name: string): Promise<boolean> | boolean;
+}
+export interface RealtimeProvider {
+    websocket?: {
+        route(options: any): (req: Request, server: any) => Promise<Response>;
+        broadcastAll(payload: any, options?: any): void;
+        broadcastToRoom(room: string, payload: any, options?: any): void;
+        handlers?(): any;
+    };
+}

package/dist/shared/core/ulid.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A fast, native ULID (Universally Unique Lexicographically Sortable Identifier) generator.
+ * Zero dependencies, utilizing Bun's native crypto.getRandomValues().
+ */
+export declare function ulid(seedTime?: number): string;

package/dist/shared/core/validator.d.ts

@@ -0,0 +1,32 @@
+import { type TSchema } from "@sinclair/typebox";
+import type { CollectionConfig } from "./types";
+/**
+ * Build a TypeBox object schema for creating a document in the given collection.
+ * - Required fields (non-optional) are marked required
+ * - Password fields are excluded — password only lives in auth endpoints (register/login/etc)
+ * - @omit fields are excluded — server-managed only, never accepted via API
+ * - System fields (id, createdAt, updatedAt) are omitted from input
+ * - Undeclared fields are not allowed (TypeCompiler strict mode)
+ */
+export declare function buildCollectionCreateSchema(collection: CollectionConfig): TSchema;
+/**
+ * Build a TypeBox object schema for updating a document in the given collection.
+ * - All fields are optional (partial update)
+ * - Password fields are excluded — password only lives in auth endpoints
+ * - @omit fields are excluded — server-managed only, never accepted via API
+ * - System fields (id, createdAt, updatedAt) are omitted from input
+ * - Undeclared fields are not allowed
+ */
+export declare function buildCollectionUpdateSchema(collection: CollectionConfig): TSchema;
+/**
+ * Validate data against the collection's create schema.
+ * Throws CequreError.BadRequest on validation failure.
+ * If the collection has no fields defined, validation is skipped (cannot validate against nothing).
+ */
+export declare function validateCreate(collection: CollectionConfig, data: unknown): Record<string, unknown>;
+/**
+ * Validate data against the collection's update schema.
+ * Throws CequreError.BadRequest on validation failure.
+ * If the collection has no fields defined, validation is skipped.
+ */
+export declare function validateUpdate(collection: CollectionConfig, data: unknown): Record<string, unknown>;

package/dist/shared/main/access-evaluator.d.ts

@@ -0,0 +1,13 @@
+import type { WhereClause } from "../core/adapter";
+import type { CequreRequestContext } from "./access";
+export type EvalResult = boolean | WhereClause<any> | null;
+/**
+ * Evaluates a DSL access expression AST node against a runtime context.
+ *
+ * Returns:
+ * - `true` → operation allowed
+ * - `false` → operation denied
+ * - `WhereClause` → operation allowed, query scoped (read only)
+ * - `null` → intermediate value (null literal), treated as falsy by callers
+ */
+export declare function evaluateAccessExpression(expr: any, ctx: CequreRequestContext, action?: string): EvalResult;

package/dist/shared/main/access.d.ts

@@ -0,0 +1,34 @@
+import type { CequreRuntime } from "../../shared/main/runtime";
+import type { WhereClause } from "../core/adapter";
+import type { ExtractAuthUser } from "../core/request";
+export interface AuthUser {
+    id: string;
+    role: string;
+    [key: string]: any;
+}
+export interface CequreRequestContext<TCollections extends Record<string, any> = any, TState = unknown, TAuthUser extends AuthUser = ExtractAuthUser<TCollections>> {
+    request: Request;
+    user: TAuthUser | null;
+    cequre: CequreRuntime<TCollections>;
+    state?: TState;
+    route?: any;
+    id?: string;
+    data?: unknown;
+}
+export type AccessControlFunction<TDoc = any, TCollections extends Record<string, any> = any, TAuthUser extends AuthUser = AuthUser> = (ctx: CequreRequestContext<TCollections, unknown, TAuthUser>) => boolean | WhereClause<TDoc> | Promise<boolean | WhereClause<TDoc>>;
+export interface AccessRules<TDoc = any, TCollections extends Record<string, any> = any, TAuthUser extends AuthUser = AuthUser> {
+    read?: AccessControlFunction<TDoc, TCollections, TAuthUser>;
+    create?: AccessControlFunction<TDoc, TCollections, TAuthUser>;
+    update?: AccessControlFunction<TDoc, TCollections, TAuthUser>;
+    delete?: AccessControlFunction<TDoc, TCollections, TAuthUser>;
+    register?: AccessControlFunction<TDoc, TCollections, TAuthUser>;
+    login?: AccessControlFunction<TDoc, TCollections, TAuthUser>;
+    refresh?: AccessControlFunction<TDoc, TCollections, TAuthUser>;
+    logout?: AccessControlFunction<TDoc, TCollections, TAuthUser>;
+    forgotPassword?: AccessControlFunction<TDoc, TCollections, TAuthUser>;
+    resetPassword?: AccessControlFunction<TDoc, TCollections, TAuthUser>;
+    mfaLogin?: AccessControlFunction<TDoc, TCollections, TAuthUser>;
+    mfaEnroll?: AccessControlFunction<TDoc, TCollections, TAuthUser>;
+    mfaVerify?: AccessControlFunction<TDoc, TCollections, TAuthUser>;
+    mfaDisable?: AccessControlFunction<TDoc, TCollections, TAuthUser>;
+}

package/dist/shared/main/aot.d.ts

@@ -0,0 +1,3 @@
+import type { CequreNativeRouteOptions } from "../../shared/main/router";
+export declare function compileRouteHandler(route: any, // CompiledRoute
+options: CequreNativeRouteOptions<any>, ctx: Record<string, any>): (request: Request, server: any) => Response | undefined | Promise<Response | undefined>;

package/dist/shared/main/hooks.d.ts

@@ -0,0 +1,76 @@
+import type { AuthUser, CequreRequestContext } from "./access";
+export interface HookContext<TCollections extends Record<string, any> = any, TAuthUser extends AuthUser = AuthUser> extends CequreRequestContext<TCollections, unknown, TAuthUser> {
+    collection: string;
+}
+export type HookFunction<T = Record<string, unknown>, TCollections extends Record<string, any> = any, TAuthUser extends AuthUser = AuthUser> = (ctx: HookContext<TCollections, TAuthUser> & {
+    data: T;
+}) => T | Promise<T> | void | Promise<void>;
+export interface Hooks<T = Record<string, unknown>, TCollections extends Record<string, any> = any, TAuthUser extends AuthUser = AuthUser> {
+    beforeCreate?: HookFunction<T, TCollections, TAuthUser>;
+    afterCreate?: HookFunction<T, TCollections, TAuthUser>;
+    beforeRead?: HookFunction<any, TCollections, TAuthUser>;
+    afterRead?: HookFunction<any, TCollections, TAuthUser>;
+    beforeUpdate?: HookFunction<T, TCollections, TAuthUser>;
+    afterUpdate?: HookFunction<T, TCollections, TAuthUser>;
+    beforeDelete?: HookFunction<T, TCollections, TAuthUser>;
+    afterDelete?: HookFunction<T, TCollections, TAuthUser>;
+    beforeLogin?: HookFunction<{
+        email?: string;
+        password?: string;
+    } & Record<string, unknown>, TCollections, TAuthUser>;
+    afterLogin?: HookFunction<{
+        user?: T;
+        tokens?: {
+            accessToken: string;
+            refreshToken?: string;
+        };
+        challenge?: string;
+        message?: string;
+    }, TCollections, TAuthUser>;
+    beforeRegister?: HookFunction<Partial<T> & Record<string, unknown>, TCollections, TAuthUser>;
+    afterRegister?: HookFunction<{
+        user: T;
+        tokens?: {
+            accessToken: string;
+            refreshToken?: string;
+        };
+    }, TCollections, TAuthUser>;
+    beforeForgotPassword?: HookFunction<{
+        email?: string;
+    } & Record<string, unknown>, TCollections, TAuthUser>;
+    afterForgotPassword?: HookFunction<{
+        user: T;
+        resetUrl: string;
+        token: string;
+    }, TCollections, TAuthUser>;
+    beforeResetPassword?: HookFunction<{
+        token?: string;
+        password?: string;
+    } & Record<string, unknown>, TCollections, TAuthUser>;
+    afterResetPassword?: HookFunction<{
+        user: T;
+    }, TCollections, TAuthUser>;
+    beforeMfaVerify?: HookFunction<{
+        token?: string;
+        code?: string;
+    } & Record<string, unknown>, TCollections, TAuthUser>;
+    afterMfaVerify?: HookFunction<{
+        user: T;
+    }, TCollections, TAuthUser>;
+    beforeMfaEnroll?: HookFunction<any, TCollections, TAuthUser>;
+    afterMfaEnroll?: HookFunction<{
+        user: T;
+    }, TCollections, TAuthUser>;
+    beforeMfaLogin?: HookFunction<{
+        email?: string;
+        password?: string;
+        code?: string;
+    } & Record<string, unknown>, TCollections, TAuthUser>;
+    afterMfaLogin?: HookFunction<{
+        user: T;
+        tokens?: {
+            accessToken: string;
+            refreshToken?: string;
+        };
+    }, TCollections, TAuthUser>;
+}

package/dist/shared/main/population.d.ts

@@ -0,0 +1,13 @@
+import type { CequreAST } from "../core/types";
+import type { CequreAdapter } from "../core/adapter";
+/**
+ * Recursively populates relationship fields within a set of documents up to a maximum depth of 2.
+ * Uses batched queries via the 'in' operator to avoid N+1 issues.
+ *
+ * @param schema - The full Cequre AST schema to lookup relations
+ * @param collectionSlug - The slug of the collection the docs belong to
+ * @param docs - The array of documents to hydrate
+ * @param adapter - The underlying storage adapter to fetch related records
+ * @param depth - The remaining depth to populate (clamps to max 2 initially)
+ */
+export declare function populateDocuments(schema: CequreAST, collectionSlug: string, docs: any[], adapter: CequreAdapter, depth: number): Promise<any[]>;

package/dist/shared/main/router.d.ts

@@ -0,0 +1,112 @@
+import type { TSchema, Static } from "@sinclair/typebox";
+import type { CequreRuntime } from "./runtime";
+import type { CequreRouteContext, CequreParams, CequreQuery } from "../core/request";
+import { type BunRouteResult } from "../../adapters/bun/bun-response";
+import type { CequreMonitoringAPI } from "@cequrebackends/cequre-plugin-monitoring";
+export type CequreRouteHandler<TCollections extends Record<string, any> = any, TState = unknown, TParams extends TSchema | undefined = undefined, TQuery extends TSchema | undefined = undefined, TBody extends TSchema | undefined = undefined, TResponse extends TSchema | undefined = undefined> = (context: CequreRouteContext<TCollections, TState, TParams extends TSchema ? Static<TParams> : CequreParams, TQuery extends TSchema ? Static<TQuery> : CequreQuery, TBody extends TSchema ? Static<TBody> : unknown>) => TResponse extends TSchema ? BunRouteResult<Static<TResponse>> | Promise<BunRouteResult<Static<TResponse>>> : BunRouteResult | Promise<BunRouteResult>;
+export interface CequreRouteOptions<TParams extends TSchema | undefined = undefined, TQuery extends TSchema | undefined = undefined, TBody extends TSchema | undefined = undefined, TResponse extends TSchema | undefined = undefined> {
+    body?: TBody;
+    query?: TQuery;
+    params?: TParams;
+    response?: TResponse;
+    detail?: {
+        summary?: string;
+        description?: string;
+        tags?: string[];
+        [key: string]: any;
+    };
+    /**
+     * If true, SDKs will generate this endpoint as a streaming client (.streamRequest)
+     */
+    stream?: boolean;
+    /**
+     * When true the route requires an authentication credential on every
+     * request. Used by plugin guards and admin-only routes that should never
+     * accept anonymous callers, regardless of the route handler body.
+     */
+    authRequired?: boolean;
+    /**
+     * Ignore the global API prefix when registering this route.
+     */
+    ignorePrefix?: boolean;
+    /**
+     * Run one or more guard functions before the main handler.
+     * If a Response is returned, execution halts and returns that response.
+     */
+    beforeHandle?: ((context: CequreRouteContext<any, any, any, any, any>) => any) | Array<(context: CequreRouteContext<any, any, any, any, any>) => any>;
+}
+export interface CequreRoute<TCollections extends Record<string, any> = any, TState = unknown, TParams extends TSchema | undefined = undefined, TQuery extends TSchema | undefined = undefined, TBody extends TSchema | undefined = undefined, TResponse extends TSchema | undefined = undefined> {
+    method: string;
+    path: string;
+    handler: CequreRouteHandler<TCollections, TState, TParams, TQuery, TBody, TResponse>;
+    options?: CequreRouteOptions<TParams, TQuery, TBody, TResponse>;
+}
+interface CompiledRoute<TCollections extends Record<string, any> = any, TState = unknown, TParams extends TSchema | undefined = undefined, TQuery extends TSchema | undefined = undefined, TBody extends TSchema | undefined = undefined, TResponse extends TSchema | undefined = undefined> extends CequreRoute<TCollections, TState, TParams, TQuery, TBody, TResponse> {
+    segments: string[];
+    bodyCoercer?: SchemaCoercer;
+    queryCoercer?: SchemaCoercer;
+    paramsCoercer?: SchemaCoercer;
+    shouldReadBody: boolean;
+}
+type NativeBunRequest = Request & {
+    params?: CequreParams;
+};
+type NativeBunRouteHandler = (request: NativeBunRequest, server: Bun.Server<unknown> | undefined) => Response | undefined | Promise<Response | undefined>;
+type SchemaCoercer = (value: unknown) => unknown;
+export type CequreNativeRoutes = Record<string, NativeBunRouteHandler | Partial<Record<string, NativeBunRouteHandler | Response>> | Response | false>;
+export interface CequreNativeRouteOptions<TState = unknown> {
+    state?: TState | ((server?: Bun.Server<unknown>) => TState);
+    resolveUser?: (request: Request) => CequreRouteContext["user"] | Promise<CequreRouteContext["user"]>;
+    onError?: (error: unknown, request: Request) => Response;
+    headers?: Record<string, string>;
+    cors?: any["cors"];
+    /**
+     * Server-known set of origins allowed to issue state-changing cookie-
+     * authenticated requests. When set, the CSRF guard accepts these origins
+     * regardless of Host parsing.
+     */
+    csrfTrustedOrigins?: string[];
+    cequre?: CequreRuntime;
+    plugins?: any[];
+    monitoring?: CequreMonitoringAPI;
+    requestId?: {
+        enabled?: boolean;
+    };
+    /** Optional rate limiter checked before the route handler runs. */
+    rateLimiter?: {
+        check: (request: Request) => Promise<Response | null> | Response | null;
+    };
+    /** Maximum request body size in bytes. Requests exceeding this are rejected before body read. */
+    maxBodyBytes?: number;
+    /** Optional KV store for idempotency key caching on POST/PUT/PATCH. */
+    idempotencyKV?: {
+        get: (key: string) => Promise<any | null>;
+        set: (key: string, value: any, ttl?: number) => Promise<void>;
+    };
+}
+export declare class CequreRouter<TCollections extends Record<string, any> = any, TState = unknown> {
+    private routes;
+    private prefix;
+    constructor(prefix?: string);
+    /**
+     * Prepends the configured prefix to a path if the path doesn't already start with it.
+     * Routes registered with an explicit prefix (e.g. internal routes using `${prefix}`)
+     * won't be double-prefixed. Routes registered without the prefix (e.g. user custom
+     * routes like "/greeting") get the prefix auto-prepended.
+     */
+    private applyPrefix;
+    matchRoute(method: string, pathname: string): CompiledRoute<TCollections, TState, any, any, any, any> | undefined;
+    add<TParams extends TSchema | undefined = undefined, TQuery extends TSchema | undefined = undefined, TBody extends TSchema | undefined = undefined, TResponse extends TSchema | undefined = undefined>(method: string, path: string, handler: CequreRouteHandler<TCollections, TState, TParams, TQuery, TBody, TResponse>, options?: CequreRouteOptions<TParams, TQuery, TBody, TResponse>): this;
+    get<TParams extends TSchema | undefined = undefined, TQuery extends TSchema | undefined = undefined, TBody extends TSchema | undefined = undefined, TResponse extends TSchema | undefined = undefined>(path: string, handler: CequreRouteHandler<TCollections, TState, TParams, TQuery, TBody, TResponse>, options?: CequreRouteOptions<TParams, TQuery, TBody, TResponse>): this;
+    post<TParams extends TSchema | undefined = undefined, TQuery extends TSchema | undefined = undefined, TBody extends TSchema | undefined = undefined, TResponse extends TSchema | undefined = undefined>(path: string, handler: CequreRouteHandler<TCollections, TState, TParams, TQuery, TBody, TResponse>, options?: CequreRouteOptions<TParams, TQuery, TBody, TResponse>): this;
+    put<TParams extends TSchema | undefined = undefined, TQuery extends TSchema | undefined = undefined, TBody extends TSchema | undefined = undefined, TResponse extends TSchema | undefined = undefined>(path: string, handler: CequreRouteHandler<TCollections, TState, TParams, TQuery, TBody, TResponse>, options?: CequreRouteOptions<TParams, TQuery, TBody, TResponse>): this;
+    patch<TParams extends TSchema | undefined = undefined, TQuery extends TSchema | undefined = undefined, TBody extends TSchema | undefined = undefined, TResponse extends TSchema | undefined = undefined>(path: string, handler: CequreRouteHandler<TCollections, TState, TParams, TQuery, TBody, TResponse>, options?: CequreRouteOptions<TParams, TQuery, TBody, TResponse>): this;
+    delete<TParams extends TSchema | undefined = undefined, TQuery extends TSchema | undefined = undefined, TBody extends TSchema | undefined = undefined, TResponse extends TSchema | undefined = undefined>(path: string, handler: CequreRouteHandler<TCollections, TState, TParams, TQuery, TBody, TResponse>, options?: CequreRouteOptions<TParams, TQuery, TBody, TResponse>): this;
+    all<TParams extends TSchema | undefined = undefined, TQuery extends TSchema | undefined = undefined, TBody extends TSchema | undefined = undefined, TResponse extends TSchema | undefined = undefined>(path: string, handler: CequreRouteHandler<TCollections, TState, TParams, TQuery, TBody, TResponse>, options?: CequreRouteOptions<TParams, TQuery, TBody, TResponse>): this;
+    list(): CequreRoute<TCollections, TState, any, any, any, any>[];
+    use(routes: CequreRouter<TCollections, TState> | CequreRoute<TCollections, TState, any, any, any, any>[] | undefined | null): this;
+    toNativeRoutes(options?: CequreNativeRouteOptions<TState>): CequreNativeRoutes;
+    handle(request: Request, state?: TState, user?: CequreRouteContext<any>["user"], cequre?: import("./runtime").CequreRuntime<any>): Promise<Response | undefined>;
+}
+export declare function createRouter<TCollections extends Record<string, any> = any, TState = unknown>(): CequreRouter<TCollections, TState>;
+export {};