@tiddlywiki/mws 0.0.21 → 0.1.1

package/dist/server.d.ts

@@ -1,945 +0,0 @@
-import * as http from 'http';
-import { Server, IncomingMessage, ServerResponse } from 'http';
-import { Readable } from 'stream';
-import { PassThrough, Writable } from 'node:stream';
-import * as z from 'zod';
-import { z as z$1, ZodEffects } from 'zod';
-import { PrismaClient, Prisma } from '@prisma/client';
-import * as fs from 'fs';
-import * as tiddlywiki from 'tiddlywiki';
-import { TW, TiddlerFieldModule } from 'tiddlywiki';
-import { ITXClientDenyList, Types } from '@prisma/client/runtime/library';
-import * as commander from 'commander';
-import { SqlMigrationAwareDriverAdapterFactory, SqlDriverAdapter } from '@prisma/driver-adapter-utils';
-import * as http2 from 'node:http2';
-import * as http2$1 from 'http2';
-import { OutgoingHttpHeaders, IncomingHttpHeaders as IncomingHttpHeaders$1, IncomingMessage as IncomingMessage$1, ServerResponse as ServerResponse$1 } from 'node:http';
-
-interface AuthUser {
-    /** User ID. 0 if the user is not logged in. */
-    user_id: PrismaField<"Users", "user_id">;
-    /** User role_ids. This may have length even if the user isn't logged in, to allow ACL for anon. */
-    role_ids: PrismaField<"Roles", "role_id">[];
-    /** Username passed to the client */
-    username: PrismaField<"Users", "username">;
-    /** A session_id isn't guarenteed. There may be a session even if the user isn't logged in, and may not be even if they are, depending on the the situation. */
-    sessionId: PrismaField<"Sessions", "session_id"> | undefined;
-    /** Is this user considered a site-admin. This is determined by the auth service, not MWS. */
-    isAdmin: boolean;
-    /** Is the user logged in? This also means that user_id should be 0. role_ids may still be specified. */
-    isLoggedIn: boolean;
-}
-declare const SessionKeyMap: RouterKeyMap<SessionManager, true>;
-/**
- *
- * @param path path starting with a forward slash
- * @param zodRequest the zod for state.data
- * @param inner the handler to call
- * @returns the ZodRoute
- */
-declare function zodSession<P extends string, T extends z$1.ZodTypeAny, R extends JsonValue>(path: P, zodRequest: (z: Z2<"JSON">) => T, inner: (state: ZodState<"POST", "json", Record<string, z$1.ZodTypeAny>, T>, prisma: PrismaTxnClient) => Promise<R>): ZodSessionRoute<P, T, R>;
-interface ZodSessionRoute<P extends string, T extends z$1.ZodTypeAny, R extends JsonValue> extends ZodAction<T, R> {
-    path: P;
-    inner: (state: ZodState<"POST", "json", {}, T>) => Promise<R>;
-}
-type RouterPathRouteMap<T> = {
-    [K in keyof T as T[K] extends ZodSessionRoute<any, any, any> ? K : never]: T[K] extends {
-        path: infer P;
-        zodRequest: (z: any) => infer REQ extends z$1.ZodTypeAny;
-        zodResponse?: (z: any) => infer RES extends z$1.ZodType<JsonValue>;
-    } ? {
-        (data: z$1.input<REQ>): Promise<jsonify<z$1.output<RES>>>;
-        path: P;
-        key: K;
-    } : never;
-};
-type SessionManagerMap = RouterPathRouteMap<SessionManager>;
-declare class SessionManager {
-    static defineRoutes(root: rootRoute): Promise<void>;
-    static parseIncomingRequest(streamer: Streamer, router: Router): Promise<AuthUser>;
-    login1: ZodSessionRoute<"/login/1", z$1.ZodObject<{
-        username: z$1.ZodEffects<any, string & {
-            __prisma_table: "Users";
-            __prisma_field: "username";
-        }, string>;
-        startLoginRequest: z$1.ZodString;
-    }, "strip", z$1.ZodTypeAny, {
-        username: string & {
-            __prisma_table: "Users";
-            __prisma_field: "username";
-        };
-        startLoginRequest: string;
-    }, {
-        username: string;
-        startLoginRequest: string;
-    }>, {
-        loginResponse: string;
-        loginSession: string;
-    }>;
-    login2: ZodSessionRoute<"/login/2", z$1.ZodObject<{
-        finishLoginRequest: z$1.ZodString;
-        loginSession: z$1.ZodString;
-        skipCookie: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodBoolean>>;
-    }, "strip", z$1.ZodTypeAny, {
-        loginSession: string;
-        finishLoginRequest: string;
-        skipCookie: boolean;
-    }, {
-        loginSession: string;
-        finishLoginRequest: string;
-        skipCookie?: boolean | undefined;
-    }>, {
-        user_id: number & {
-            __prisma_table: "Users";
-            __prisma_field: "user_id";
-        };
-        session_id: string & {
-            __prisma_table: "Sessions";
-            __prisma_field: "session_id";
-        };
-    }>;
-    logout: ZodSessionRoute<"/logout", z$1.ZodOptional<z$1.ZodObject<{
-        session_id: z$1.ZodString;
-        signature: z$1.ZodString;
-        skipCookie: z$1.ZodEffects<z$1.ZodBoolean, boolean, boolean>;
-    }, "strip", z$1.ZodTypeAny, {
-        session_id: string;
-        skipCookie: boolean;
-        signature: string;
-    }, {
-        session_id: string;
-        skipCookie: boolean;
-        signature: string;
-    }>>, null>;
-}
-declare function assertSignature({ session_id, signature, session_key }: {
-    session_id: string;
-    signature: string;
-    session_key: string;
-}): void;
-
-declare function setupDevServer<T extends StateObject>(enableDevServer: boolean, pathPrefix: string): Promise<(state: T) => Promise<symbol>>;
-
-interface TiddlerFields extends Record<string, any> {
-    title: PrismaField<"Tiddlers", "title">;
-}
-declare class AttachmentService {
-    protected config: SiteConfig;
-    protected prisma: PrismaTxnClient;
-    constructor(config: SiteConfig, prisma: PrismaTxnClient);
-    makeCanonicalUri(bag_name: string, title: string): string;
-    processOutgoingTiddler({ tiddler, tiddler_id, bag_name, attachment_hash }: {
-        tiddler: TiddlerFields;
-        tiddler_id: any;
-        bag_name: PrismaField<"Bags", "bag_name">;
-        attachment_hash: PrismaField<"Tiddlers", "attachment_hash">;
-    }): TiddlerFields;
-    processIncomingTiddler({ tiddlerFields, existing_attachment_hash, existing_canonical_uri }: {
-        tiddlerFields: TiddlerFields;
-        existing_attachment_hash: PrismaField<"Tiddlers", "attachment_hash">;
-        existing_canonical_uri: any;
-    }): Promise<{
-        tiddlerFields: TiddlerFields;
-        attachment_hash: PrismaField<"Tiddlers", "attachment_hash">;
-    }>;
-    isValidAttachmentName(content_hash: string): boolean;
-    saveAttachment(options: {
-        text: string;
-        type: string;
-        reference: string;
-        _canonical_uri: string;
-    }): Promise<PrismaField<"Tiddlers", "attachment_hash">>;
-    private writeMetaFile;
-    adoptAttachment({ incomingFilepath, type, hash, _canonical_uri }: {
-        incomingFilepath: any;
-        type: string | number;
-        hash: any;
-        _canonical_uri: any;
-    }): Promise<any>;
-    getAttachmentStream(content_hash: string): Promise<{
-        stream: fs.ReadStream;
-        type: any;
-    } | null>;
-    getAttachmentFileSize(content_hash: PrismaField<"Tiddlers", "attachment_hash"> & {}): Promise<number | null>;
-    getAttachmentMetadata(content_hash: PrismaField<"Tiddlers", "attachment_hash"> & {}): Promise<any>;
-}
-
-type PasswordService = Awaited<ReturnType<typeof createPasswordService>>;
-declare function createPasswordService(serverSetup: string): Promise<{
-    serverState: Map<string, TypedGenerator<LoginGeneratorStates>>;
-    LoginGenerator: (args_0: {
-        user_id: PrismaField<"Users", "user_id">;
-        startLoginRequest: string;
-        registrationRecord: string;
-    }) => TypedGenerator<LoginGeneratorStates>;
-    PasswordCreation: (userID: string, password: string) => Promise<string & {
-        __prisma_table: "Users";
-        __prisma_field: "password";
-    }>;
-    createRegistrationResponse: ({ userID, registrationRequest }: {
-        userID: PrismaField<"Users", "user_id">;
-        registrationRequest: string;
-    }) => Promise<string>;
-    startLoginSession: (stater: TypedGenerator<LoginGeneratorStates>) => Promise<string>;
-    finishLoginSession: (loginSession: string) => Promise<TypedGenerator<LoginGeneratorStates> | undefined>;
-}>;
-type LoginGeneratorStates = [
-    [
-        void,
-        loginResponse: string
-    ],
-    [
-        finishLoginRequest: string,
-        {
-            user_id: PrismaField<"Users", "user_id">;
-            session: {
-                sessionKey: string;
-            } | undefined;
-        }
-    ]
-];
-
-declare class ListenerBase {
-    server: http2.Http2SecureServer | Server;
-    router: Router;
-    bindInfo: string;
-    constructor(server: http2.Http2SecureServer | Server, router: Router, bindInfo: string);
-    handleRequest(req: IncomingMessage | http2.Http2ServerRequest, res: ServerResponse | http2.Http2ServerResponse): void;
-}
-declare class Command {
-    params: string[];
-    commander: Commander;
-    execute: () => Promise<void>;
-    get $tw(): tiddlywiki.TW;
-    constructor(params: string[], commander: Commander, listenConfig: MWSConfig["listeners"], onListenersCreated: MWSConfig["onListenersCreated"]);
-}
-
-declare class SqliteAdapter {
-    private databasePath;
-    constructor(databasePath: string);
-    adapter: SqlMigrationAwareDriverAdapterFactory;
-    init(): Promise<void>;
-    createMigrationsTable(libsql: SqlDriverAdapter): Promise<void>;
-    checkMigrationsTable(libsql: SqlDriverAdapter, migrateExisting: boolean): Promise<void>;
-}
-
-declare class StartupCommander {
-    config: MWSConfig;
-    $tw: TW;
-    PasswordService: PasswordService;
-    fieldModules: Record<string, TiddlerFieldModule>;
-    versions: {
-        tiddlywiki: any;
-        mws: string;
-    };
-    constructor(config: MWSConfig, $tw: TW, PasswordService: PasswordService);
-    init(): Promise<void>;
-    wikiPath: string;
-    storePath: string;
-    databasePath: string;
-    cachePath: string;
-    adapter: SqliteAdapter;
-    engine: PrismaClient<Prisma.PrismaClientOptions, never, {
-        result: {
-            [T in Uncapitalize<Prisma.ModelName>]: {
-                [K in keyof PrismaPayloadScalars<Capitalize<T>>]: () => {
-                    compute: () => PrismaField<Capitalize<T>, K>;
-                };
-            };
-        };
-        client: {};
-        model: {};
-        query: {};
-    }>;
-    $transaction<R>(fn: (prisma: Omit<Commander["engine"], ITXClientDenyList>) => Promise<R>, options?: {
-        maxWait?: number;
-        timeout?: number;
-        isolationLevel?: Prisma.TransactionIsolationLevel;
-    }): Promise<R>;
-    siteConfig: SiteConfig;
-    SessionManager: typeof SessionManager;
-    AttachmentService: typeof AttachmentService;
-    /** Signals that database setup is required. May be set to false by any qualified setup command. */
-    setupRequired: boolean;
-    outputPath: string;
-}
-/**
-Parse a sequence of commands
-  commandTokens: an array of command string tokens
-  wiki: reference to the wiki store object
-  streams: {output:, error:}, each of which has a write(string) method
-  callback: a callback invoked as callback(err) where err is null if there was no error
-*/
-declare class Commander extends StartupCommander {
-    constructor(config: MWSConfig, $tw: TW, PasswordService: PasswordService);
-    program: commander.Command;
-    init(): Promise<void>;
-    create_mws_listen: (params: string[]) => Command;
-    /**
-     * The promise of the current execution.
-     * It is created and returned by execute,
-     * but also accessible here.
-     *
-     * After the promise is resolved, it will
-     * be available until execute is called again.
-     */
-    promise: Promise<void>;
-    private callback;
-    commandTokens: string[];
-    nextToken: number;
-    verbose: boolean;
-    static initCommands(moduleType?: string): void;
-    addCommandTokens(params: string[]): void;
-    execute(commandTokens: string[]): Promise<void>;
-    executeInternal(commandTokens: string[]): Promise<void>;
-    setPromise(): void;
-    executeNextCommand(): void;
-    extractNamedParameters(params: string[], mandatoryParameters?: string[]): any;
-}
-
-declare class StateObject<B extends BodyFormat = BodyFormat, M extends AllowedMethod = AllowedMethod, RoutePathParams extends string[][] = string[][], D = unknown> extends StreamerState {
-    /** The array of Route tree nodes the request matched. */
-    private routePath;
-    /** The bodyformat that ended up taking precedence. This should be correctly typed. */
-    bodyFormat: B;
-    user: AuthUser;
-    router: Router;
-    tiddlerCache: Router["tiddlerCache"];
-    z: typeof z;
-    STREAM_ENDED: typeof STREAM_ENDED;
-    get method(): M;
-    readMultipartData: (options: {
-        cbPartStart: (headers: http.IncomingHttpHeaders, name: string | null, filename: string | null) => void;
-        cbPartChunk: (chunk: Buffer) => void;
-        cbPartEnd: () => void;
-        cbFinished: (err: Error | string | null) => void;
-    }) => Promise<void>;
-    sendResponse: (statusCode: number, headers: http.OutgoingHttpHeaders, data: string | Buffer<ArrayBufferLike>, encoding?: BufferEncoding | undefined) => Promise<symbol>;
-    /** This is set in makeRouter */
-    sendDevServer: () => ReturnType<Awaited<ReturnType<typeof setupDevServer>>>;
-    data: B extends "string" ? string : B extends "buffer" ? Buffer : B extends "www-form-urlencoded-urlsearchparams" ? URLSearchParams : B extends "stream" ? Readable : B extends "ignore" ? undefined : D;
-    /**
-     * an *object from entries* of all the pathParams in the tree mapped to the path regex matches from that route.
-     *
-     * Object.fromEntries takes the last value if there are duplicates, so conflicting names will have the last value in the path.
-     *
-     * Conflicting names would be defined on the route definitions, so just change the name there if there is a conflict.
-     */
-    pathParams: Record<RoutePathParams extends (infer X extends string)[][] ? X : never, string | undefined>;
-    /**
-     * The query params. Because these aren't checked anywhere,
-     * the value includes undefined since it will be that if
-     * the key is not specified at all.
-     *
-     * This will always satisfy the zod schema: `z.record(z.array(z.string()))`
-     */
-    queryParams: Record<string, string[] | undefined>;
-    private engine;
-    config: SiteConfig;
-    PasswordService: PasswordService;
-    get pathPrefix(): string;
-    constructor(streamer: Streamer, 
-    /** The array of Route tree nodes the request matched. */
-    routePath: RouteMatch[], 
-    /** The bodyformat that ended up taking precedence. This should be correctly typed. */
-    bodyFormat: B, user: AuthUser, router: Router, tiddlerCache: Router["tiddlerCache"]);
-    okUser(): void;
-    okAdmin(): void;
-    $transaction: <T>(fn: (prisma: PrismaTxnClient) => Promise<T>) => Promise<T>;
-    $transactionTuple<P extends Prisma.PrismaPromise<any>[]>(arg: (prisma: Commander["engine"]) => [...P], options?: {
-        isolationLevel?: Prisma.TransactionIsolationLevel;
-    }): Promise<Types.Utils.UnwrapTuple<P>>;
-    makeTiddlerEtag(options: {
-        bag_name: string;
-        tiddler_id: string | number;
-    }): string;
-    /** type-narrowing helper function. This affects anywhere T is used. */
-    isBodyFormat<T extends B, S extends {
-        [K in B]: StateObject<K, M, RoutePathParams, D>;
-    }[T]>(format: T): this is S;
-    /**
-     *
-     * Sends a **302** status code and **Location** header to the client.
-     *
-     *
-     * - **301 Moved Permanently:** The resource has been permanently moved to a new URL.
-     * - **302 Found:** The resource is temporarily located at a different URL.
-     * - **303 See Other:** Fetch the resource from another URI using a GET request.
-     * - **307 Temporary Redirect:** The resource is temporarily located at a different URL; the same HTTP method should be used.
-     * - **308 Permanent Redirect:** The resource has permanently moved; the client should use the new URL in future requests.
-     */
-    redirect(location: string, pushLocation?: boolean): typeof STREAM_ENDED;
-    sendSSE(retryMilliseconds?: number): {
-        /** Emit an SSE event */
-        emitEvent: (eventName: string, eventData: any, eventId: string) => void;
-        emitComment: (comment: string) => boolean;
-        close: () => PassThrough;
-        onClose: (callback: () => void) => PassThrough;
-    };
-    checkACL(entityType: EntityType, entityName: string, permissionName: ACLPermissionName): Promise<void>;
-    getRecipeACL(recipe_name: PrismaField<"Recipes", "recipe_name">, needWrite: boolean): Promise<{
-        recipe: {
-            recipe_id: number & {
-                __prisma_table: "Recipes";
-                __prisma_field: "recipe_id";
-            };
-        } | null;
-        canRead: unknown;
-        canWrite: unknown;
-    }>;
-    assertRecipeACL(recipe_name: PrismaField<"Recipes", "recipe_name">, needWrite: boolean): Promise<void>;
-    getBagACL(bag_name: PrismaField<"Bags", "bag_name">, needWrite: boolean): Promise<{
-        bag: {
-            bag_id: number & {
-                __prisma_table: "Bags";
-                __prisma_field: "bag_id";
-            };
-            owner_id: PrismaField<"Bags", "owner_id">;
-            is_plugin: PrismaField<"Bags", "is_plugin">;
-        } | null;
-        canRead: unknown;
-        canWrite: unknown;
-    }>;
-    assertBagACL(bag_name: PrismaField<"Bags", "bag_name">, needWrite: boolean): Promise<{
-        bag_id: number & {
-            __prisma_table: "Bags";
-            __prisma_field: "bag_id";
-        };
-        owner_id: PrismaField<"Bags", "owner_id">;
-        is_plugin: PrismaField<"Bags", "is_plugin">;
-    }>;
-}
-
-declare class TypedGenerator<T extends [any, any][]> {
-    private inner;
-    private index;
-    static checker<T extends [any, any][]>(): {
-        /** `const value1 = asV(1, yield asY(0, value0))` */
-        asV<I extends number>(index: I, args: T[I][0]): T[I][0];
-        /** `const value1 = asV(1, yield asY(0, value0))` */
-        asY<I extends number>(index: I, ret: T[I][1]): T[I][1];
-    };
-    static wrapper<T extends [any, any][]>(): <A extends any[]>(factory: (...args: A) => Generator<any, any, any>) => (...args: A) => TypedGenerator<T>;
-    constructor(inner: Generator<any, any, any>, index?: number);
-    next<I extends number>(index: I, ...args: T[I][0] extends void ? [] : [T[I][0]]): Promise<(T extends [...any[], T[I]] ? IteratorReturnResult<T[I][1]> : IteratorYieldResult<T[I][1]>)>;
-    return(value: any): any;
-    throw(e: any): any;
-}
-declare interface JsonArray extends Array<JsonValue> {
-}
-declare type JsonObject = {
-    [Key in string]?: JsonValue;
-};
-declare type JsonValue = string | number | boolean | JsonObject | JsonArray | null | Date;
-
-interface Route extends RouteDef<ParentTuple, string[]> {
-}
-interface rootRoute$1 extends RouteDef<[
-    undefined,
-    AllowedMethod[],
-    StateObject<BodyFormat, AllowedMethod>,
-    [
-        []
-    ]
-], []> {
-}
-interface RouteMatch {
-    route: Route;
-    params: (string | undefined)[];
-    remainingPath: string;
-}
-type DetermineRouteOptions<P extends ParentTuple, PA extends string[]> = P extends [BodyFormat, AllowedMethod[], any, any] ? RouteOptBase<P[0], P[1], PA> & {
-    bodyFormat?: undefined;
-} : P extends [undefined, AllowedMethod[], any, any] ? {
-    [K in BodyFormat]: RouteOptBase<K, P[1], PA> & {
-        bodyFormat: K;
-    };
-}[BodyFormat] | RouteOptBase<BodyFormat, P[1], PA> & {
-    bodyFormat?: undefined;
-} : never;
-type ParentTuple = [BodyFormat | undefined, AllowedMethod[], any, string[][]];
-interface RouteOptBase<B extends BodyFormat, M extends AllowedMethod[], PA extends string[]> {
-    /**
-     * Regex to test the pathname on. It must start with `^`. If this is a child route,
-     * it will be tested against the remaining portion of the parent route.
-     */
-    path: RegExp;
-    pathParams?: PA;
-    /** The uppercase method names to match this route */
-    method: M;
-    /**
-     * The highest bodyformat in the chain always takes precedent. Type-wise, only one is allowed,
-     * but at runtime the first one found is the one used.
-     *
-     * Note that bodyFormat is completely ignored for GET and HEAD requests.
-     */
-    bodyFormat?: B;
-    /** If this route is the last one matched, it will NOT be called, and a 404 will be returned. */
-    denyFinal?: boolean;
-}
-interface RouteDef<P extends ParentTuple, PA extends string[]> extends RouteOptBase<P[0] & {}, P[1], PA> {
-    /**
-     * If this route's handler sends headers, the matched child route will not be called.
-     */
-    handler: (state: StateObject<P[0] extends undefined ? BodyFormat : (P[0] & {}), P[1][number], [...P[3], [...PA]], unknown>) => Promise<P[2]>;
-    /**
-     * ### ROUTING
-     *
-     * @param route The route definition.
-     *
-     * If the parent route sends headers, or returns the STREAM_ENDED symbol,
-     * this route will not be called.
-     *
-     * Inner routes are matched on the remaining portion of the parent route
-     * using `pathname.slice(match[0].length)`. If the parent route entirely
-     * matches the pathname, this route will be matched on "/".
-     *
-     * If the body format is "stream", "buffer", "ignore" or not yet defined at this level in the tree,
-     * then zod cannot be used.
-     *
-     * Note that GET and HEAD are always bodyFormat: "ignore", regardless of what is set here.
-     */
-    defineRoute: <R, PA extends string[], T extends (P extends [BodyFormat, AllowedMethod[], any, any] ? RouteOptBase<P[0], P[1], [...PA]> & {
-        bodyFormat?: undefined;
-    } : P extends [undefined, AllowedMethod[], any, any] ? {
-        [K in BodyFormat]: RouteOptBase<K, P[1], [...PA]> & {
-            bodyFormat: K;
-        };
-    }[BodyFormat] | RouteOptBase<BodyFormat, P[1], [...PA]> & {
-        bodyFormat?: undefined;
-    } : never)>(route: T, handler: (
-    /**
-     * The state object for this route.
-     *
-     * If the route only specifies "GET" and/or "HEAD", then the bodyFormat can only be "ignore"
-     *
-     * Otherwise, the bodyFormat is determined by the first parent route that specifies it.
-     *
-     * The state object is wrapped in a proxy which throws if methods return a promise that
-     * doesn't get awaited before the next property access. It only enforces the first layer
-     * of properties, so if you have a nested object, you will need to wrap it in a proxy as well.
-     *
-     * store and store.sql will probably also be wrapped in this proxy.
-     */
-    state: StateObject<(Exclude<T["method"][number], "GET" | "HEAD"> extends never ? never : (P[0] extends BodyFormat ? P[0] : T["bodyFormat"] extends BodyFormat ? T["bodyFormat"] : BodyFormat)) | (T["method"][number] extends "GET" | "HEAD" ? "ignore" : never), T["method"][number], getPA<P, T>, unknown>) => Promise<R>) => P[0] extends BodyFormat ? RouteDef<[P[0], T["method"], R, P[3]], [...PA]> : T["bodyFormat"] extends BodyFormat ? RouteDef<[T["bodyFormat"], T["method"], R, P[3]], [...PA]> : RouteDef<[undefined, T["method"], R, P[3]], [...PA]>;
-    $o?: P;
-}
-type getPA<P extends ParentTuple, T extends DetermineRouteOptions<P, any>> = [
-    ...P[3],
-    ...T["pathParams"] extends string[] ? [T["pathParams"]] : []
-];
-
-type _zod = typeof z$1;
-type FieldTypeGroups = "STRING" | "JSON";
-type FieldTypeStringSelector<T extends FieldTypeGroups> = T extends "STRING" ? "string" : "string";
-type FieldTypeNumberSelector<T extends FieldTypeGroups> = T extends "STRING" ? "parse-number" : "number";
-type FieldTypeBooleanSelector<T extends FieldTypeGroups> = T extends "STRING" ? "parse-boolean" : "boolean";
-interface Z2<T extends FieldTypeGroups> extends _zod {
-    /**
-     * Tags the resulting value as being from the specified table field.
-     *
-     * The third argument is a string literal that specifies the field type based on the selected field.
-     *
-     * "string" and "parse-number"
-     * - will use decodeURIComponent on the value.
-     * - Require a string length at least one
-     *
-     * You can use .optional(), .nullable(), .nulish() after this to make the field optional.
-     */
-    prismaField<Table extends Prisma.ModelName, Field extends keyof PrismaPayloadScalars<Table>>(table: Table, field: Field, fieldtype: string extends (PrismaPayloadScalars<Table>[Field]) ? FieldTypeStringSelector<T> : number extends (PrismaPayloadScalars<Table>[Field]) ? FieldTypeNumberSelector<T> : boolean extends (PrismaPayloadScalars<Table>[Field]) ? FieldTypeBooleanSelector<T> : never, nullable?: null extends PrismaPayloadScalars<Table>[Field] ? true : false): ZodEffects<any, PrismaField<Table, Field>, PrismaPayloadScalars<Table>[Field]>;
-    authUser(): z$1.ZodNullable<z$1.ZodObject<{
-        user_id: z$1.ZodNumber;
-        isAdmin: z$1.ZodBoolean;
-        username: z$1.ZodString;
-        sessionId: z$1.ZodNumber;
-    }>>;
-}
-declare const Z2: Z2<FieldTypeGroups>;
-
-declare global {
-    type PrismaTxnClient = Omit<Commander["engine"], "$connect" | "$disconnect" | "$on" | "$transaction" | "$use" | "$extends">;
-    type ART<T extends (...args: any) => any> = Awaited<ReturnType<T>>;
-    type Complete<T> = {
-        [K in keyof T]-?: T[K];
-    };
-    /**
-     * This primarily makes sure that positional arguments are used correctly
-     * (so you can't switch a title and bag_name around).
-     *
-     * If you assign the wrong value (like `5 as PrismaField<"Bags", "bag_name">`),
-     * this will result in a type error on the as keyword, allowing you to catch incorrect types quickly.
-    */
-    type PrismaField<T extends Prisma.ModelName, K extends keyof PrismaPayloadScalars<T>> = ([
-        T,
-        K
-    ] extends ["Tiddlers", "bag_id"] ? PrismaField<"Bags", "bag_id"> : [
-        T,
-        K
-    ] extends ["Sessions", "user_id"] ? PrismaField<"Users", "user_id"> : [
-        T,
-        K
-    ] extends ["Recipe_bags", "bag_id"] ? PrismaField<"Bags", "bag_id"> : [
-        T,
-        K
-    ] extends ["Recipe_bags", "recipe_id"] ? PrismaField<"Recipes", "recipe_id"> : [
-        T,
-        K
-    ] extends ["Recipes", "owner_id"] ? PrismaField<"Users", "user_id"> : [
-        T,
-        K
-    ] extends ["Bags", "owner_id"] ? PrismaField<"Users", "user_id"> : (PrismaPayloadScalars<T>[K] & {
-        __prisma_table: T;
-        __prisma_field: K;
-    })) | (null extends PrismaPayloadScalars<T>[K] ? null : never);
-    type PrismaPayloadScalars<T extends Prisma.ModelName> = Prisma.TypeMap["model"][T]["payload"]["scalars"];
-    type EntityName<T extends EntityType> = T extends "bag" ? PrismaField<"Bags", "bag_name"> : T extends "recipe" ? PrismaField<"Recipes", "recipe_name"> : never;
-    type EntityType = "recipe" | "bag";
-    type ACLPermissionName = "READ" | "WRITE" | "ADMIN";
-    type rootRoute = rootRoute$1;
-    type ZodAssert = typeof ZodAssert;
-}
-declare global {
-    function hop(object: any, property: any): boolean;
-    function each<T>(object: T[], callback: (value: T, index: number, object: T[]) => void): void;
-    function each<T>(object: Record<string, T>, callback: (value: T, key: string, object: Record<string, T>) => void): void;
-    function eachAsync<T>(object: T[], callback: (value: T, index: number, object: T[]) => void): Promise<void>;
-    function eachAsync<T>(object: Record<string, T>, callback: (value: T, key: string, object: Record<string, T>) => void): Promise<void>;
-    function createDirectory(dirPath: string): void;
-    function deleteDirectory(dirPath: string): void;
-    function encodeURIComponentExtended(s: string): string;
-}
-declare class _Result<OK extends boolean, T> {
-    ok: OK;
-    error: OK extends true ? undefined : unknown;
-    value: OK extends true ? T : undefined;
-    constructor(ok: OK, error: OK extends true ? undefined : unknown, value: OK extends true ? T : undefined);
-    get [Symbol.iterator](): (OK | (OK extends true ? undefined : unknown) | (OK extends true ? T : undefined))[];
-    static ok<T>(value: T): _Result<true, T>;
-    static error(error: unknown): _Result<false, undefined>;
-    /**
-     * @example
-     * // const result = try something();
-     * const result = Result.try_(() => {
-     *   something();
-     * });
-     */
-    static try_<T, This>(callback: (this: This) => T, thisarg: This): _Result<false, undefined> | _Result<true, T>;
-}
-declare global {
-    const TryResult: typeof _Result;
-    interface Promise<T> {
-        try: () => Promise<_Result<true, T> | _Result<false, T>>;
-    }
-}
-
-declare module 'node:net' {
-    interface Socket {
-        /** Not defined on net.Socket instances.
-         *
-         * On tls.Socket instances,  */
-        encrypted?: boolean;
-    }
-}
-interface IncomingHttpHeaders extends IncomingHttpHeaders$1 {
-    "accept-encoding"?: string;
-}
-declare const STREAM_ENDED: unique symbol;
-/**
- * The HTTP2 shims used in the request handler are only used for HTTP2 requests.
- * The NodeJS HTTP2 server actually calls the HTTP1 parser for all HTTP1 requests.
- */
-declare class Streamer {
-    private req;
-    private res;
-    private router;
-    host: string;
-    method: AllowedMethod;
-    urlInfo: URL;
-    url: string;
-    headers: IncomingHttpHeaders;
-    isSecure: boolean;
-    cookies: URLSearchParams;
-    constructor(req: IncomingMessage$1 | http2.Http2ServerRequest, res: ServerResponse$1 | http2.Http2ServerResponse, router: Router);
-    parseCookieString(cookieString: string): URLSearchParams;
-    get reader(): Readable;
-    get writer(): Writable;
-    throw(statusCode: number): void;
-    catcher: (error: unknown) => void;
-    checkHeadersSentBy(setError: boolean): void;
-    toHeadersMap(headers: {
-        [x: string]: string | string[] | number | undefined;
-    }): Map<string, string[]>;
-    readBody: () => Promise<Buffer<ArrayBufferLike>>;
-    sendEmpty(status: number, headers?: OutgoingHttpHeaders): typeof STREAM_ENDED;
-    sendString(status: number, headers: OutgoingHttpHeaders, data: string, encoding: NodeJS.BufferEncoding): typeof STREAM_ENDED;
-    sendBuffer(status: number, headers: OutgoingHttpHeaders, data: Buffer): typeof STREAM_ENDED;
-    /** If this is a HEAD request, the stream will be ignored AND LEFT OPEN. */
-    sendStream(status: number, headers: OutgoingHttpHeaders, stream: Readable): typeof STREAM_ENDED;
-    private sendFD;
-    /**
-     * Sends a file with the appropriate cache headers, using the `send` npm module.
-     *
-     * Think of it like a static file server where you are serving files from a directory.
-     *
-     * @param options.root The directory to serve files from.
-     * @param options.reqpath The path to the file relative to the `root` directory.
-     * @param options.offset The offset in bytes to start reading the file from.
-     * @param options.length The number of bytes to read from the file.
-     * @param options.index "index.html" by default, to disable this set false or
-     * to supply a new index pass a string or an array in preferred order.
-     *
-     * If an index.html file is not found, `send` will NOT generate a directory listing.
-     *
-     * The `send` method will automatically set the `Content-Type` header based on the file extension.
-     *
-     * If the file is not found, the `send` method will automatically send a 404 response.
-     *
-  
-     * @returns STREAM_ENDED
-     */
-    sendFile(status: number, headers: OutgoingHttpHeaders, options: {
-        root: string;
-        reqpath: string;
-        offset?: number;
-        length?: number;
-        index?: string | boolean | string[] | undefined;
-        on404?: () => Promise<typeof STREAM_ENDED>;
-        onDir?: () => Promise<typeof STREAM_ENDED>;
-    }): Promise<typeof STREAM_ENDED>;
-    setCookie(name: string, value: string, options: {
-        domain?: string;
-        path?: string;
-        expires?: Date;
-        maxAge?: number;
-        secure?: boolean;
-        httpOnly?: boolean;
-        sameSite?: "Strict" | "Lax" | "None";
-    }): void;
-    appendHeader(name: string, value: string): void;
-    setHeader(name: string, value: string): void;
-    writeHead(status: number, headers?: OutgoingHttpHeaders): void;
-    write(chunk: Buffer | string, encoding?: NodeJS.BufferEncoding): void;
-    end(): typeof STREAM_ENDED;
-    get headersSent(): boolean;
-    headersSentBy: Error | undefined;
-}
-declare class StreamerState {
-    private streamer;
-    readBody: () => Promise<Buffer<ArrayBufferLike>>;
-    sendEmpty: (status: number, headers?: OutgoingHttpHeaders) => typeof STREAM_ENDED;
-    sendString: (status: number, headers: OutgoingHttpHeaders, data: string, encoding: NodeJS.BufferEncoding) => typeof STREAM_ENDED;
-    sendBuffer: (status: number, headers: OutgoingHttpHeaders, data: Buffer) => typeof STREAM_ENDED;
-    sendStream: (status: number, headers: OutgoingHttpHeaders, stream: Readable) => typeof STREAM_ENDED;
-    sendFile: (status: number, headers: OutgoingHttpHeaders, options: {
-        root: string;
-        reqpath: string;
-        offset?: number;
-        length?: number;
-        index?: string | boolean | string[] | undefined;
-        on404?: () => Promise<typeof STREAM_ENDED>;
-        onDir?: () => Promise<typeof STREAM_ENDED>;
-    }) => Promise<typeof STREAM_ENDED>;
-    setCookie: (name: string, value: string, options: {
-        domain?: string;
-        path?: string;
-        expires?: Date;
-        maxAge?: number;
-        secure?: boolean;
-        httpOnly?: boolean;
-        sameSite?: "Strict" | "Lax" | "None";
-    }) => void;
-    /**
-     *
-     * Sets a single header value. If the header already exists in the to-be-sent
-     * headers, its value will be replaced. Use an array of strings to send multiple
-     * headers with the same name
-     *
-     * When headers have been set with `response.setHeader()`, they will be merged
-     * with any headers passed to `response.writeHead()`, with the headers passed
-     * to `response.writeHead()` given precedence.
-     *
-     */
-    setHeader: (name: string, value: string) => void;
-    writeHead: (status: number, headers?: OutgoingHttpHeaders) => void;
-    write: (chunk: Buffer | string, encoding?: NodeJS.BufferEncoding) => void;
-    end: () => typeof STREAM_ENDED;
-    /** sends a status and plain text string body */
-    sendSimple(status: number, msg: string): typeof STREAM_ENDED;
-    /** Stringify the value (unconditionally) and send it with content-type `application/json` */
-    sendJSON<T>(status: number, obj: T): typeof STREAM_ENDED;
-    STREAM_ENDED: typeof STREAM_ENDED;
-    constructor(streamer: Streamer);
-    get url(): string;
-    get method(): AllowedMethod;
-    get headers(): IncomingHttpHeaders;
-    get host(): string;
-    get urlInfo(): URL;
-    get headersSent(): boolean;
-    get reader(): Readable;
-    /** Currently this is based on whether the socket is secure, so a proxy will cause problems. */
-    get isSecure(): boolean;
-    get cookies(): URLSearchParams;
-}
-
-declare function startupCache(rootRoute: rootRoute, commander: Commander): Promise<{
-    tiddlerFiles: Map<any, any>;
-    tiddlerHashes: Map<any, any>;
-}>;
-type CacheState = ART<typeof startupCache>;
-
-declare const AllowedMethods: ("POST" | "GET" | "HEAD" | "OPTIONS" | "PUT" | "DELETE")[];
-type AllowedMethod = typeof AllowedMethods[number];
-declare const BodyFormats: readonly ["stream", "string", "json", "buffer", "www-form-urlencoded", "www-form-urlencoded-urlsearchparams", "ignore"];
-type BodyFormat = typeof BodyFormats[number];
-declare class Router {
-    private rootRoute;
-    private tiddlerCache;
-    static makeRouter(commander: Commander, enableDevServer: boolean): Promise<Router>;
-    enableBrowserCache: boolean;
-    enableGzip: boolean;
-    csrfDisable: boolean;
-    siteConfig: SiteConfig;
-    get pathPrefix(): string;
-    engine: Commander["engine"];
-    private SessionManager;
-    PasswordService: Commander["PasswordService"];
-    versions: {
-        tiddlywiki: any;
-        mws: string;
-    };
-    fieldModules: Commander["$tw"]["Tiddler"]["fieldModules"];
-    AttachmentService: Commander["AttachmentService"];
-    constructor(rootRoute: rootRoute$1, commander: Commander, tiddlerCache: CacheState);
-    handleIncomingRequest(req: http.IncomingMessage | http2$1.Http2ServerRequest, res: http.ServerResponse | http2$1.Http2ServerResponse): void;
-    handle(streamer: Streamer): Promise<void | typeof STREAM_ENDED>;
-    handleRoute(state: StateObject<BodyFormat>, route: RouteMatch[]): Promise<void>;
-    findRouteRecursive(routes: Route[], testPath: string, method: AllowedMethod): RouteMatch[];
-    /**
-     *
-     * Top-level function that starts matching from the root routes.
-     * Notice that the pathPrefix is assumed to have been handled beforehand.
-     *
-     * @param streamer
-     * @returns The tree path matched
-     */
-    findRoute(streamer: Streamer): RouteMatch[];
-}
-interface ZodAction<T extends z.ZodTypeAny, R extends JsonValue> {
-    inner: (route: z.output<T>) => Promise<R>;
-    zodRequest: (z: Z2<"JSON">) => T;
-    zodResponse?: (z: Z2<"JSON">) => z.ZodType<R>;
-}
-declare class ZodState<M extends AllowedMethod, B extends BodyFormat, P extends Record<string, z.ZodTypeAny>, T extends z.ZodTypeAny> extends StateObject<B, M, string[][], z.output<T>> {
-    pathParams: z.output<z.ZodObject<P>>;
-}
-type jsonify<T> = T extends void ? null : T extends Promise<any> ? unknown : T extends Date ? string : T extends string | number | boolean | null | undefined ? T : T extends [...any[]] ? number extends T["length"] ? jsonify<T[number]>[] : [...jsonifyTuple<T>] : T extends Array<infer U> ? jsonify<U>[] : T extends object ? {
-    [K in keyof T]: jsonify<T[K]>;
-} : unknown;
-type jsonifyTuple<T> = T extends [infer A, ...infer B] ? [jsonify<A>, ...jsonifyTuple<B>] : T extends [infer A] ? [jsonify<A>] : [];
-type RouterKeyMap<T, V> = {
-    [K in keyof T as T[K] extends ZodAction<any, any> ? K : never]: V;
-};
-
-interface MWSConfig {
-    /**
-     * Listener config for the mws-listen command.
-     * This is extracted from the config early and passed directly to mws-listen.
-     */
-    listeners: {
-        /** The key file for the HTTPS server. If either key or cert are set, both are required, and HTTPS is enforced. */
-        key?: string;
-        /** The cert file for the HTTPS server. If either key or cert are set, both are required, and HTTPS is enforced. */
-        cert?: string;
-        /** The port to listen on. If not specified, listen will not be called. */
-        port?: number;
-        /** The hostname to listen on. If this is specified, then port is required. */
-        host?: string;
-    }[];
-    /**
-     * Called and awaited by the mws-listen command.
-     * This is extracted from the config early and passed directly to mws-listen.
-     */
-    onListenersCreated?: (listeners: ListenerBase[]) => Promise<void>;
-    /**
-     * Enables the dev configuration of the server.
-     */
-    enableDevServer?: boolean;
-    /**
-     * Path or file descriptor to the password master key.
-     * If this key changes, all passwords will be invalid and need to be changed.
-     */
-    passwordMasterKeyFile: string | number;
-    onPasswordKeyFileRead?: () => void;
-    /** Path to the datafolder. */
-    wikiPath: string;
-    /** MWS site configuration */
-    config?: MWSConfigConfig;
-    /**
-     * The session manager class registers the login handler routes and sets the auth user
-     */
-    SessionManager?: typeof SessionManager;
-    /**
-     * The attachment service class is used by routes to handle attachments
-     */
-    AttachmentService?: typeof AttachmentService;
-}
-interface MWSConfigConfig {
-    /** If true, allow users that aren't logged in to read. */
-    readonly allowAnonReads?: boolean;
-    /** If true, allow users that aren't logged in to write. */
-    readonly allowAnonWrites?: boolean;
-    /** If true, recipes will allow access to a user who does not have read access to all its bags. */
-    readonly allowUnreadableBags?: boolean;
-    /** If true, files larger than `this * 1024` will be saved to disk alongside the database instead of in the database. */
-    readonly saveLargeTextToFileSystem?: number;
-    readonly enableGzip?: boolean;
-    readonly enableBrowserCache?: boolean;
-    /** The path prefix must start with a slash, and end without a slash */
-    readonly pathPrefix?: string;
-    readonly enablePluginCache?: boolean;
-}
-interface SiteConfig extends Complete<MWSConfigConfig> {
-    wikiPath: string;
-    attachmentSizeLimit: number;
-    attachmentsEnabled: boolean;
-    contentTypeInfo: Record<string, any>;
-    saveLargeTextToFileSystem: never;
-    storePath: string;
-    /**
-     * The path prefix is a essentially folder mount point.
-     *
-     * It starts with a slash, and ends without a slash (`"/dev"`).
-     *
-     * If there is not a prefix, it is an empty string (`""`).
-     */
-    pathPrefix: string;
-}
-/**
- *
- * The promise returned will resolve once the commander has completed.
- * It will reject if the commander or anything else throws an error.
- *
-```
-import startServer from "./src/server.ts";
-
-startServer({
-  // enableDevServer: true,
-  passwordMasterKey: "./localpass.key",
-  listeners: [{
-    key: "./localhost.key",
-    cert: "./localhost.crt",
-    port: 5000,
-  }],
-  config: {
-    wikiPath: "./editions/mws",
-    allowAnonReads: false,
-    allowAnonWrites: false,
-    allowUnreadableBags: false,
-  },
-});
-
-```
- */
-declare function startServer(config: MWSConfig): Promise<void>;
-
-export { type AuthUser, type MWSConfig, type MWSConfigConfig, type RouterPathRouteMap, SessionKeyMap, SessionManager, type SessionManagerMap, type SiteConfig, type ZodSessionRoute, assertSignature, startServer as default, zodSession };