@modelence/react-query 1.0.2 → 1.2.0

package/.yalc/modelence/dist/types-WgRbQ-tj.d.ts

@@ -0,0 +1,645 @@
+import './index-CwdohC5n.js';
+import { P as Permission, d as Session, e as UserInfo } from './types-Ds1ESQSs.js';
+import * as mongodb from 'mongodb';
+import { WithId, IndexDescription, SearchIndexDescription, MongoClient, Collection, FilterOperators, Document, FindOptions, ObjectId, OptionalUnlessRequiredId, InsertOneResult, InsertManyResult, UpdateFilter, UpdateResult, ClientSession, DeleteResult, AggregateOptions, AggregationCursor, AnyBulkWriteOperation, BulkWriteResult } from 'mongodb';
+import { z, ZodNumber, ZodArray } from 'zod';
+import { Request, Response, NextFunction } from 'express';
+
+type EmailAttachment = {
+    filename: string;
+    content: Buffer | string;
+    contentType: string;
+};
+type EmailPayload = {
+    from: string;
+    to: string | string[];
+    subject: string;
+    html?: string;
+    text?: string;
+    cc?: string | string[];
+    bcc?: string | string[];
+    replyTo?: string | string[];
+    headers?: Record<string, string>;
+    attachments?: EmailAttachment[];
+} & ({
+    html: string;
+} | {
+    text: string;
+});
+interface EmailProvider {
+    sendEmail(data: EmailPayload): Promise<void>;
+}
+
+type ClientInfo = {
+    screenWidth: number;
+    screenHeight: number;
+    windowWidth: number;
+    windowHeight: number;
+    pixelRatio: number;
+    orientation: string | null;
+};
+type ConnectionInfo = {
+    ip?: string;
+    userAgent?: string;
+    acceptLanguage?: string;
+    referrer?: string;
+    baseUrl?: string;
+};
+type Context = {
+    session: Session | null;
+    user: UserInfo | null;
+    roles: string[];
+    clientInfo: ClientInfo;
+    connectionInfo: ConnectionInfo;
+};
+type Args = Record<string, unknown>;
+type Handler<T = unknown> = (args: Args, context: Context) => Promise<T> | T;
+type MethodType = 'query' | 'mutation';
+type MethodDefinition<T = unknown> = {
+    permissions?: Permission[];
+    handler: Handler<T>;
+} | Handler<T>;
+type Method<T = unknown> = {
+    type: MethodType;
+    name: string;
+    permissions: Permission[];
+    handler: Handler<T>;
+};
+
+type RateLimitType = 'ip' | 'user';
+type RateLimitRule = {
+    /** Logical action being limited, e.g. "signup" */
+    bucket: string;
+    /** Identifier type of the actor this rule applies to */
+    type: RateLimitType;
+    /** Time window size in milliseconds */
+    window: number;
+    /** Maximum allowed hits within the window */
+    limit: number;
+};
+
+type CronJobHandler = () => Promise<void>;
+type CronJob = {
+    alias: string;
+    params: {
+        description: string;
+        interval: number;
+        timeout: number;
+    };
+    handler: CronJobHandler;
+    state: {
+        startTs?: number;
+        scheduledRunTs?: number;
+        isRunning: boolean;
+    };
+};
+type CronJobInputParams = {
+    description?: string;
+    interval: number;
+    timeout?: number;
+    handler: CronJobHandler;
+};
+type CronJobMetadata = {
+    alias: string;
+    description: string;
+    interval: number;
+    timeout: number;
+};
+
+interface SerializedModelSchema {
+    [key: string]: SerializedSchema | (SerializedSchema | SerializedModelSchema)[] | SerializedModelSchema | 'v2';
+}
+type BaseSerializedSchema = {
+    type: 'string';
+} | {
+    type: 'number';
+} | {
+    type: 'boolean';
+} | {
+    type: 'date';
+} | {
+    type: 'array';
+    items: SerializedSchema;
+} | {
+    type: 'object';
+    items: Record<string, SerializedSchema>;
+} | {
+    type: 'enum';
+    items: readonly string[];
+} | {
+    type: 'union';
+    items: SerializedSchema[];
+} | {
+    type: 'custom';
+    typeName: string;
+};
+type SerializedSchema = BaseSerializedSchema | (BaseSerializedSchema & {
+    optional: true;
+});
+
+/**
+ * Top-level query operators (logical and evaluation) - custom version without Document index signature
+ * Based on MongoDB's RootFilterOperators but without the [key: string]: any from Document
+ * @internal
+ */
+type StrictRootFilterOperators<TSchema> = {
+    $and?: TypedFilter<TSchema>[];
+    $or?: TypedFilter<TSchema>[];
+    $nor?: TypedFilter<TSchema>[];
+    $not?: TypedFilter<TSchema>;
+    $text?: {
+        $search: string;
+        $language?: string;
+        $caseSensitive?: boolean;
+        $diacriticSensitive?: boolean;
+    };
+    $where?: string | ((this: TSchema) => boolean);
+    $comment?: string | Document;
+    $expr?: any;
+    $jsonSchema?: any;
+};
+/**
+ * Type-safe MongoDB filter that ensures only schema fields can be queried
+ * while supporting all MongoDB query operators and dot notation for nested fields.
+ *
+ * This type combines:
+ * - MongoDB's native `FilterOperators<T>` for field-level operators (comprehensive operator support)
+ * - Custom `StrictRootFilterOperators<T>` for top-level operators without index signature
+ * - Custom restriction: only strings containing dots are allowed for nested field queries
+ *
+ * @example
+ * ```ts
+ * const dbUsers = new Store('users', {
+ *   schema: {
+ *     name: schema.string(),
+ *     age: schema.number(),
+ *     tags: schema.array(schema.string()),
+ *     address: schema.object({
+ *       street: schema.string(),
+ *       city: schema.string(),
+ *     }),
+ *   },
+ *   indexes: []
+ * });
+ *
+ * // ✅ Valid - field exists in schema
+ * await dbUsers.findOne({ name: 'John' });
+ *
+ * // ✅ Valid - using MongoDB operators (from FilterOperators)
+ * await dbUsers.findOne({ age: { $gt: 18 } });
+ * await dbUsers.findOne({ tags: { $in: ['typescript', 'mongodb'] } });
+ * await dbUsers.findOne({ $or: [{ name: 'John' }, { name: 'Jane' }] });
+ *
+ * // ✅ Valid - dot notation for nested fields (must contain a dot)
+ * await dbUsers.findOne({ 'address.city': 'New York' });
+ * await dbUsers.findOne({ 'emails.0.address': 'test@example.com' });
+ *
+ * // ❌ TypeScript error - 'id' is not in schema and doesn't contain a dot
+ * await dbUsers.findOne({ id: '123' });
+ * ```
+ */
+type TypedFilter<T> = {
+    [K in keyof WithId<T>]?: WithId<T>[K] | FilterOperators<WithId<T>[K]>;
+} & StrictRootFilterOperators<T> & {
+    [K: DottedString]: any;
+};
+/**
+ * Helper type to preserve method types when extending a store.
+ * Maps each method to work with the extended schema while preserving signatures.
+ * @internal
+ */
+type PreserveMethodsForExtendedSchema<TBaseMethods extends Record<string, (...args: never[]) => unknown>, TExtendedSchema extends ModelSchema> = {
+    [K in keyof TBaseMethods]: TBaseMethods[K] extends (this: any, ...args: infer Args) => infer Return ? (this: WithId<InferDocumentType<TExtendedSchema>> & any, ...args: Args) => Return : never;
+};
+/**
+ * The Store class provides a type-safe interface for MongoDB collections with built-in schema validation and helper methods.
+ *
+ * @category Store
+ * @typeParam TSchema - The document schema type
+ * @typeParam TMethods - Custom methods that will be added to documents
+ *
+ * @example
+ * ```ts
+ * const dbTodos = new Store('todos', {
+ *   schema: {
+ *     title: schema.string(),
+ *     completed: schema.boolean(),
+ *     dueDate: schema.date().optional(),
+ *     userId: schema.userId(),
+ *   },
+ *   methods: {
+ *     isOverdue() {
+ *       return this.dueDate < new Date();
+ *     }
+ *   }
+ * });
+ * ```
+ */
+declare class Store<TSchema extends ModelSchema, TMethods extends Record<string, (this: WithId<InferDocumentType<TSchema>> & TMethods, ...args: any[]) => any>> {
+    /** @internal */
+    readonly _type: InferDocumentType<TSchema>;
+    /** @internal */
+    readonly _rawDoc: WithId<this['_type']>;
+    /** @internal */
+    readonly _doc: this['_rawDoc'] & TMethods;
+    readonly Doc: this['_doc'];
+    private name;
+    private readonly schema;
+    private readonly methods?;
+    private readonly indexes;
+    private readonly searchIndexes;
+    private collection?;
+    private client?;
+    /**
+     * Creates a new Store instance
+     *
+     * @param name - The collection name in MongoDB
+     * @param options - Store configuration
+     */
+    constructor(name: string, options: {
+        /** Document schema using Modelence schema types */
+        schema: TSchema;
+        /** Custom methods to add to documents */
+        methods?: TMethods;
+        /** MongoDB indexes to create */
+        indexes: IndexDescription[];
+        /** MongoDB Atlas Search */
+        searchIndexes?: SearchIndexDescription[];
+    });
+    getName(): string;
+    /** @internal */
+    getSchema(): TSchema;
+    /** @internal */
+    getSerializedSchema(): SerializedModelSchema;
+    /**
+     * Extends the store with additional schema fields, indexes, methods, and search indexes.
+     * Returns a new Store instance with the extended schema and updated types.
+     * Methods from the original store are preserved with updated type signatures.
+     *
+     * @param config - Additional schema fields, indexes, methods, and search indexes to add
+     * @returns A new Store instance with the extended schema
+     *
+     * @example
+     * ```ts
+     * // Extend the users collection
+     * export const dbUsers = baseUsersCollection.extend({
+     *   schema: {
+     *     firstName: schema.string(),
+     *     lastName: schema.string(),
+     *     companyId: schema.objectId().optional(),
+     *   },
+     *   indexes: [
+     *     { key: { companyId: 1 } },
+     *     { key: { lastName: 1, firstName: 1 } },
+     *   ],
+     *   methods: {
+     *     getFullName() {
+     *       return `${this.firstName} ${this.lastName}`;
+     *     }
+     *   }
+     * });
+     *
+     * // Now fully typed with new fields
+     * const user = await dbUsers.findOne({ firstName: 'John' });
+     * console.log(user?.getFullName());
+     * ```
+     */
+    extend<TExtendedSchema extends ModelSchema, TExtendedMethods extends Record<string, (this: WithId<InferDocumentType<TSchema & TExtendedSchema>> & any, ...args: any[]) => any> = Record<string, never>>(config: {
+        schema?: TExtendedSchema;
+        indexes?: IndexDescription[];
+        methods?: TExtendedMethods;
+        searchIndexes?: SearchIndexDescription[];
+    }): Store<TSchema & TExtendedSchema, PreserveMethodsForExtendedSchema<TMethods, TSchema & TExtendedSchema> & TExtendedMethods>;
+    /** @internal */
+    init(client: MongoClient): void;
+    /** @internal */
+    createIndexes(): Promise<void>;
+    private wrapDocument;
+    /**
+     * For convenience, to also allow directy passing a string or ObjectId as the selector
+     */
+    private getSelector;
+    /** @internal */
+    requireCollection(): Collection<this["_type"]>;
+    /** @internal */
+    requireClient(): MongoClient;
+    /**
+     * Finds a single document matching the query
+     *
+     * @param query - Type-safe query filter. Only schema fields, MongoDB operators, and dot notation are allowed.
+     * @param options - Find options
+     * @returns The document, or null if not found
+     *
+     * @example
+     * ```ts
+     * // ✅ Valid queries:
+     * await store.findOne({ name: 'John' })
+     * await store.findOne({ age: { $gt: 18 } })
+     * await store.findOne({ _id: new ObjectId('...') })
+     * await store.findOne({ tags: { $in: ['typescript', 'mongodb'] } })
+     * await store.findOne({ $or: [{ name: 'John' }, { name: 'Jane' }] })
+     * await store.findOne({ 'emails.address': 'test@example.com' }) // dot notation
+     *
+     * // ❌ TypeScript error - 'id' is not in schema:
+     * await store.findOne({ id: '123' })
+     * ```
+     */
+    findOne(query: TypedFilter<this['_type']>, options?: FindOptions): Promise<this["_doc"] | null>;
+    requireOne(query: TypedFilter<this['_type']>, options?: FindOptions, errorHandler?: () => Error): Promise<this['_doc']>;
+    private find;
+    /**
+     * Fetches a single document by its ID
+     *
+     * @param id - The ID of the document to find
+     * @returns The document, or null if not found
+     */
+    findById(id: string | ObjectId): Promise<this['_doc'] | null>;
+    /**
+     * Fetches a single document by its ID, or throws an error if not found
+     *
+     * @param id - The ID of the document to find
+     * @param errorHandler - Optional error handler to return a custom error if the document is not found
+     * @returns The document
+     */
+    requireById(id: string | ObjectId, errorHandler?: () => Error): Promise<this['_doc']>;
+    /**
+     * Counts the number of documents that match a query
+     *
+     * @param query - The query to filter documents
+     * @returns The number of documents that match the query
+     */
+    countDocuments(query: TypedFilter<this['_type']>): Promise<number>;
+    /**
+     * Fetches multiple documents, equivalent to Node.js MongoDB driver's `find` and `toArray` methods combined.
+     *
+     * @param query - The query to filter documents
+     * @param options - Options
+     * @returns The documents
+     */
+    fetch(query: TypedFilter<this['_type']>, options?: {
+        sort?: Document;
+        limit?: number;
+        skip?: number;
+    }): Promise<this['_doc'][]>;
+    /**
+     * Inserts a single document
+     *
+     * @param document - The document to insert
+     * @returns The result of the insert operation
+     */
+    insertOne(document: OptionalUnlessRequiredId<InferDocumentType<TSchema>>): Promise<InsertOneResult>;
+    /**
+     * Inserts multiple documents
+     *
+     * @param documents - The documents to insert
+     * @returns The result of the insert operation
+     */
+    insertMany(documents: OptionalUnlessRequiredId<InferDocumentType<TSchema>>[]): Promise<InsertManyResult>;
+    /**
+     * Updates a single document
+     *
+     * @param selector - The selector to find the document to update
+     * @param update - The update to apply to the document
+     * @returns The result of the update operation
+     */
+    updateOne(selector: TypedFilter<this['_type']> | string | ObjectId, update: UpdateFilter<this['_type']>): Promise<UpdateResult>;
+    /**
+     * Updates a single document, or inserts it if it doesn't exist
+     *
+     * @param selector - The selector to find the document to update
+     * @param update - The MongoDB modifier to apply to the document
+     * @returns The result of the update operation
+     */
+    upsertOne(selector: TypedFilter<this['_type']> | string | ObjectId, update: UpdateFilter<this['_type']>): Promise<UpdateResult>;
+    /**
+     * Updates multiple documents
+     *
+     * @param selector - The selector to find the documents to update
+     * @param update - The MongoDB modifier to apply to the documents
+     * @returns The result of the update operation
+     */
+    updateMany(selector: TypedFilter<this['_type']>, update: UpdateFilter<this['_type']>, options?: {
+        session?: ClientSession;
+    }): Promise<UpdateResult>;
+    /**
+     * Updates multiple documents, or inserts them if they don't exist
+     *
+     * @param selector - The selector to find the documents to update
+     * @param update - The MongoDB modifier to apply to the documents
+     * @returns The result of the update operation
+     */
+    upsertMany(selector: TypedFilter<this['_type']>, update: UpdateFilter<this['_type']>): Promise<UpdateResult>;
+    /**
+     * Deletes a single document
+     *
+     * @param selector - The selector to find the document to delete
+     * @returns The result of the delete operation
+     */
+    deleteOne(selector: TypedFilter<this['_type']>): Promise<DeleteResult>;
+    /**
+     * Deletes multiple documents
+     *
+     * @param selector - The selector to find the documents to delete
+     * @returns The result of the delete operation
+     */
+    deleteMany(selector: TypedFilter<this['_type']>): Promise<DeleteResult>;
+    /**
+     * Aggregates documents using MongoDB's aggregation framework
+     *
+     * @param pipeline - The aggregation pipeline
+     * @param options - Optional options
+     * @returns The aggregation cursor
+     */
+    aggregate(pipeline: Document[], options?: AggregateOptions): AggregationCursor<Document>;
+    /**
+     * Performs a bulk write operation on the collection
+     *
+     * @param operations - The operations to perform
+     * @returns The result of the bulk write operation
+     */
+    bulkWrite(operations: AnyBulkWriteOperation<this['_type']>[]): Promise<BulkWriteResult>;
+    /**
+     * Returns the raw MongoDB database instance for advanced operations
+     * @returns The MongoDB database instance
+     * @throws Error if the store is not provisioned
+     */
+    getDatabase(): mongodb.Db;
+    /**
+     * Returns the raw MongoDB collection instance for advanced operations
+     * @returns The MongoDB collection instance
+     * @throws Error if the store is not provisioned
+     */
+    rawCollection(): Collection<this["_type"]>;
+    /**
+     * Renames an existing collection to this store's name, used for migrations
+     * @param oldName - The previous name of the collection
+     * @throws Error if the old collection doesn't exist or if this store's collection already exists
+     */
+    renameFrom(oldName: string, options?: {
+        session?: ClientSession;
+    }): Promise<void>;
+    /**
+     * Performs a vector similarity search using MongoDB Atlas Vector Search
+     *
+     * @param params - Vector search parameters
+     * @param params.field - The field name containing the vector embeddings
+     * @param params.embedding - The query vector to search for
+     * @param params.numCandidates - Number of nearest neighbors to consider (default: 100)
+     * @param params.limit - Maximum number of results to return (default: 10)
+     * @param params.projection - Additional fields to include in the results
+     * @param params.indexName - Name of index (default: field + VectorSearch)
+     * @returns An aggregation cursor with search results and scores
+     *
+     * @example
+     * ```ts
+     * const results = await store.vectorSearch({
+     *   field: 'embedding',
+     *   embedding: [0.1, 0.2, 0.3, ...],
+     *   numCandidates: 100,
+     *   limit: 10,
+     *   projection: { title: 1, description: 1 }
+     * });
+     * ```
+     */
+    vectorSearch({ field, embedding, numCandidates, limit, projection, indexName, }: {
+        field: string;
+        embedding: number[];
+        numCandidates?: number;
+        limit?: number;
+        projection?: Document;
+        indexName?: string;
+    }): Promise<AggregationCursor<Document>>;
+    /**
+     * Creates a MongoDB Atlas Vector Search index definition
+     *
+     * @param params - Vector index parameters
+     * @param params.field - The field name to create the vector index on
+     * @param params.dimensions - The number of dimensions in the vector embeddings
+     * @param params.similarity - The similarity metric to use (default: 'cosine')
+     * @param params.indexName - Name of index (default: field + VectorSearch)
+     * @returns A search index description object
+     *
+     * @example
+     * ```ts
+     * const store = new Store('documents', {
+     *   schema: {
+     *     title: schema.string(),
+     *     embedding: schema.array(schema.number()),
+     *   },
+     *   indexes: [],
+     *   searchIndexes: [
+     *     Store.vectorIndex({
+     *       field: 'embedding',
+     *       dimensions: 1536,
+     *       similarity: 'cosine'
+     *     })
+     *   ]
+     * });
+     * ```
+     */
+    static vectorIndex({ field, dimensions, similarity, indexName, }: {
+        field: string;
+        dimensions: number;
+        similarity?: 'cosine' | 'euclidean' | 'dotProduct';
+        indexName?: string;
+    }): {
+        type: string;
+        name: string;
+        definition: {
+            fields: {
+                type: string;
+                path: string;
+                numDimensions: number;
+                similarity: "cosine" | "euclidean" | "dotProduct";
+            }[];
+        };
+    };
+}
+
+type ObjectTypeDefinition = {
+    [key: string]: SchemaTypeDefinition;
+};
+type SingularSchemaTypeDefinition = z.ZodType | ObjectTypeDefinition;
+type SchemaTypeDefinition = SingularSchemaTypeDefinition | Array<SingularSchemaTypeDefinition>;
+type ModelSchema = {
+    [key: string]: SchemaTypeDefinition;
+};
+type InferDocumentType<T extends SchemaTypeDefinition> = {
+    [K in keyof T as T[K] extends z.ZodOptional<z.ZodTypeAny> ? K : never]?: T[K] extends z.ZodType ? z.infer<T[K]> : never;
+} & {
+    [K in keyof T as T[K] extends z.ZodOptional<z.ZodTypeAny> ? never : K]: T[K] extends z.ZodType ? z.infer<T[K]> : T[K] extends Array<infer ElementType extends SchemaTypeDefinition> ? Array<InferDocumentType<ElementType>> : T[K] extends ObjectTypeDefinition ? InferDocumentType<T[K]> : never;
+};
+declare const schema: {
+    readonly string: (params?: z.RawCreateParams & {
+        coerce?: true;
+    }) => z.ZodString;
+    readonly number: (params?: z.RawCreateParams & {
+        coerce?: boolean;
+    }) => ZodNumber;
+    readonly date: (params?: z.RawCreateParams & {
+        coerce?: boolean;
+    }) => z.ZodDate;
+    readonly boolean: (params?: z.RawCreateParams & {
+        coerce?: boolean;
+    }) => z.ZodBoolean;
+    readonly array: <El extends z.ZodTypeAny>(schema: El, params?: z.RawCreateParams) => ZodArray<El>;
+    readonly object: <Shape extends z.ZodRawShape>(shape: Shape, params?: z.RawCreateParams) => z.ZodObject<Shape, "strip", z.ZodTypeAny, z.objectOutputType<Shape, z.ZodTypeAny, "strip">, z.objectInputType<Shape, z.ZodTypeAny, "strip">>;
+    readonly enum: {
+        <U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: z.RawCreateParams): z.ZodEnum<z.Writeable<T>>;
+        <U extends string, T extends [U, ...U[]]>(values: T, params?: z.RawCreateParams): z.ZodEnum<T>;
+    };
+    readonly embedding: () => ZodArray<ZodNumber>;
+    readonly objectId: () => z.ZodType<ObjectId>;
+    readonly userId: () => z.ZodType<ObjectId>;
+    readonly ref: <T extends ModelSchema>(_collection: string | Store<T, InferDocumentType<T>>) => z.ZodType<ObjectId>;
+    readonly union: <Options extends Readonly<[z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>>(types: Options, params?: z.RawCreateParams) => z.ZodUnion<Options>;
+    readonly infer: <T extends SchemaTypeDefinition>(_schema: T) => InferDocumentType<T>;
+};
+declare namespace schema {
+    type infer<T extends SchemaTypeDefinition> = InferDocumentType<T>;
+}
+
+type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head' | 'all' | 'use';
+type RouteParams<T = unknown> = {
+    query: Record<string, string>;
+    body: T;
+    params: Record<string, string>;
+    headers: Record<string, string>;
+    cookies: Record<string, string>;
+    rawBody?: Buffer;
+    req: Request;
+    res: Response;
+    next: NextFunction;
+};
+type RouteResponse<T = unknown> = {
+    data?: T;
+    status?: number;
+    headers?: Record<string, string>;
+    redirect?: string;
+} | null;
+type RouteHandler<T = unknown> = (params: RouteParams, context: Pick<Context, 'session' | 'user'>) => Promise<RouteResponse<T>> | RouteResponse<T>;
+type RouteHandlers = {
+    [key in HttpMethod]?: RouteHandler;
+};
+type BodyConfig = {
+    json?: boolean | {
+        limit?: string;
+    };
+    urlencoded?: boolean | {
+        limit?: string;
+        extended?: boolean;
+    };
+    raw?: boolean | {
+        limit?: string;
+        type?: string | string[];
+    };
+};
+type RouteDefinition = {
+    path: string;
+    handlers: RouteHandlers;
+    errorHandler?: RouteHandler;
+    body?: BodyConfig;
+};
+type ExpressHandler = (req: Request, res: Response) => Promise<void> | void;
+
+export { type Args as A, type BodyConfig as B, type CronJobInputParams as C, type EmailProvider as E, type HttpMethod as H, type InferDocumentType as I, type MethodDefinition as M, type RouteDefinition as R, Store as S, type RateLimitRule as a, type ConnectionInfo as b, type RateLimitType as c, type EmailPayload as d, type RouteHandler as e, type RouteParams as f, type RouteResponse as g, type EmailAttachment as h, type ClientInfo as i, type Context as j, type Handler as k, type MethodType as l, type Method as m, type CronJob as n, type CronJobMetadata as o, type ModelSchema as p, type RouteHandlers as q, type ExpressHandler as r, schema as s };

package/.yalc/modelence/dist/types.d.ts

@@ -0,0 +1,7 @@
+export { A as AppServer, E as ExpressMiddleware, M as ModelenceConfig } from './index-CwdohC5n.js';
+export { A as Args, B as BodyConfig, i as ClientInfo, b as ConnectionInfo, j as Context, n as CronJob, C as CronJobInputParams, o as CronJobMetadata, h as EmailAttachment, d as EmailPayload, E as EmailProvider, r as ExpressHandler, k as Handler, H as HttpMethod, I as InferDocumentType, m as Method, M as MethodDefinition, l as MethodType, p as ModelSchema, a as RateLimitRule, c as RateLimitType, R as RouteDefinition, e as RouteHandler, q as RouteHandlers, f as RouteParams, g as RouteResponse, s as schema } from './types-WgRbQ-tj.js';
+export { A as AppConfig, b as ConfigKey, C as ConfigSchema, g as ConfigType, h as Configs, D as DefaultRoles, P as Permission, f as Role, R as RoleDefinition, d as Session, U as User, e as UserInfo, a as WebsocketClientProvider, W as WebsocketServerProvider } from './types-Ds1ESQSs.js';
+import 'express';
+import 'mongodb';
+import 'zod';
+import 'http';

package/.yalc/modelence/dist/types.js

@@ -0,0 +1,2 @@
+import'./chunk-55J6XMHW.js';//# sourceMappingURL=types.js.map
+//# sourceMappingURL=types.js.map

package/.yalc/modelence/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"types.js"}