gramobase 1.0.0

package/dist/BotWorkerPool-9ndHQt2g.d.ts

@@ -0,0 +1,201 @@
+import { z } from 'zod';
+import TelegramBot from 'node-telegram-bot-api';
+import EventEmitter from 'eventemitter3';
+
+interface GramoBaseDocument {
+    _id: string;
+    _collection: string;
+    _msgId: number;
+    _createdAt: string;
+    _updatedAt: string;
+    [key: string]: unknown;
+}
+type WithId<T> = T & GramoBaseDocument;
+interface CollectionConfig<T extends z.ZodType> {
+    schema: T;
+    /** Channel override — uses the default if omitted */
+    channelId?: string | undefined;
+    /** Bloom-filter field list for fast-miss short-circuit */
+    indexes?: string[] | undefined;
+    /** Encrypt all documents in this collection with AES-256 */
+    encrypt?: boolean | undefined;
+    /** TTL seconds — documents are automatically expired after this many seconds */
+    ttl?: number | undefined;
+}
+type ElemOf<T> = T extends (infer U)[] ? U : T;
+type ComparisonOperator<T> = {
+    $eq?: T | ElemOf<T> | undefined;
+    $ne?: T | ElemOf<T> | undefined;
+    $gt?: T | ElemOf<T> | number | undefined;
+    $gte?: T | ElemOf<T> | number | undefined;
+    $lt?: T | ElemOf<T> | number | undefined;
+    $lte?: T | ElemOf<T> | number | undefined;
+    $in?: (T | ElemOf<T>)[] | undefined;
+    $nin?: (T | ElemOf<T>)[] | undefined;
+    $exists?: boolean | undefined;
+    $regex?: RegExp | string | undefined;
+};
+type Filter<T> = {
+    [K in keyof T]?: T[K] | ElemOf<T[K]> | ComparisonOperator<T[K]> | undefined;
+} | {
+    $and?: Filter<T>[] | undefined;
+    $or?: Filter<T>[] | undefined;
+    $not?: Filter<T> | undefined;
+};
+interface FindOptions<T> {
+    filter?: Filter<T> | undefined;
+    sort?: Partial<Record<keyof T | string, 1 | -1>> | undefined;
+    limit?: number | undefined;
+    skip?: number | undefined;
+    projection?: Partial<Record<keyof T | string, 1 | 0>> | undefined;
+    useCache?: boolean | undefined;
+}
+interface UpdateOperators<T> {
+    $set?: (Partial<T> & Record<string, unknown>) | undefined;
+    $unset?: Partial<Record<keyof T | string, '' | true>> | undefined;
+    $inc?: Partial<Record<keyof T | string, number>> | undefined;
+    $push?: Partial<Record<keyof T | string, unknown>> | undefined;
+}
+type WalOpType = 'INSERT' | 'UPDATE' | 'DELETE';
+interface WalEntry {
+    seq: number;
+    op: WalOpType;
+    collection: string;
+    id: string;
+    data?: unknown;
+    timestamp: string;
+    checksum: string;
+}
+interface Lease {
+    instanceId: string;
+    acquiredAt: number;
+    expiresAt: number;
+    heartbeatInterval: ReturnType<typeof setInterval> | null;
+}
+interface User {
+    _id: string;
+    email: string;
+    passwordHash: string;
+    roles: string[];
+    metadata?: Record<string, unknown> | undefined;
+    createdAt: string;
+    updatedAt: string;
+}
+interface Session {
+    userId: string;
+    roles: string[];
+    expiresAt: number;
+    token: string;
+}
+interface AuthConfig {
+    jwtSecret: string;
+    jwtExpiresIn?: string | undefined;
+    bcryptRounds?: number | undefined;
+    onSignIn?: ((user: User) => Promise<void>) | undefined;
+    onSignOut?: ((userId: string) => Promise<void>) | undefined;
+}
+interface UploadOptions {
+    fileName?: string | undefined;
+    mimeType?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}
+interface FileRecord {
+    _id: string;
+    fileId: string;
+    fileName: string;
+    mimeType: string;
+    sizeBytes: number;
+    url?: string | undefined;
+    uploadedAt: string;
+    metadata?: Record<string, unknown> | undefined;
+}
+type GramoBaseEvent = {
+    type: 'insert';
+    collection: string;
+    doc: unknown;
+} | {
+    type: 'update';
+    collection: string;
+    id: string;
+    changes: unknown;
+    doc: unknown;
+} | {
+    type: 'delete';
+    collection: string;
+    id: string;
+} | {
+    type: 'worker:rotate';
+    tokenIndex: number;
+} | {
+    type: 'wal:flush';
+    entries: number;
+};
+interface Migration {
+    version: number;
+    name: string;
+    up(db: unknown): Promise<void>;
+    down(db: unknown): Promise<void>;
+}
+interface GramoBaseConfig {
+    /** Bot token or array of tokens for pool rotation */
+    botToken: string | string[];
+    /** Primary storage channel ID */
+    channelId: string;
+    /** Optional separate channel for WAL entries */
+    walChannelId?: string | undefined;
+    /** Optional separate channel for collection indexes */
+    indexChannelId?: string | undefined;
+    /** AES-256 encryption key for data at rest */
+    encryptionKey?: string | undefined;
+    /** LRU cache byte limit (default: 64MB) */
+    cacheMaxBytes?: number | undefined;
+    /** LRU cache TTL in milliseconds (default: 60s) */
+    cacheTtlMs?: number | undefined;
+    /** Max concurrent requests per bot token (default: 25) */
+    concurrency?: number | undefined;
+    /** Webhook URL for realtime events (optional — falls back to polling) */
+    webhookUrl?: string | undefined;
+    /** Enable verbose debug logging */
+    debug?: boolean | undefined;
+}
+
+interface WorkerStats {
+    tokenIndex: number;
+    requestCount: number;
+    errorCount: number;
+    lastUsed: number;
+    rateLimitHits: number;
+}
+/**
+ * BotWorkerPool manages a round-robin pool of Telegram bot tokens.
+ * Each token gets its own PQueue limited to 25 concurrent requests
+ * (safe under Telegram's 30 req/s flood limit with headroom).
+ * On 429 responses, the worker is cooled down and the next token takes over.
+ */
+declare class BotWorkerPool extends EventEmitter {
+    private bots;
+    private queues;
+    private stats;
+    private currentIndex;
+    private debug;
+    constructor(tokens: string[], concurrency?: number, debug?: boolean);
+    /**
+     * Execute a Telegram API call through the pool with automatic retry
+     * and token rotation on rate limits.
+     */
+    execute<T>(fn: (bot: TelegramBot) => Promise<T>, priority?: number): Promise<T>;
+    /**
+     * Round-robin with recency bias — prefer the worker that was least recently used.
+     */
+    private pickWorker;
+    private isFloodError;
+    private isRetryableError;
+    private extractRetryAfter;
+    getBot(index?: number): TelegramBot;
+    getStats(): WorkerStats[];
+    getQueueSizes(): number[];
+    private sleep;
+    destroy(): Promise<void>;
+}
+
+export { type AuthConfig as A, BotWorkerPool as B, type CollectionConfig as C, type FileRecord as F, type GramoBaseEvent as G, type Lease as L, type Migration as M, type Session as S, type UploadOptions as U, type WorkerStats as W, type GramoBaseConfig as a, type ComparisonOperator as b, type Filter as c, type FindOptions as d, type GramoBaseDocument as e, type UpdateOperators as f, type User as g, type WalEntry as h, type WalOpType as i, type WithId as j };

package/dist/GramoBaseAuth-00fg0u_b.d.ts

@@ -0,0 +1,218 @@
+import { z } from 'zod';
+import { B as BotWorkerPool, e as GramoBaseDocument, i as WalOpType, h as WalEntry, C as CollectionConfig, j as WithId, c as Filter, d as FindOptions, f as UpdateOperators, A as AuthConfig, g as User, S as Session } from './BotWorkerPool-9ndHQt2g.js';
+import EventEmitter from 'eventemitter3';
+
+/**
+ * HotCache is an in-memory LRU cache that sits in front of Telegram storage.
+ *
+ * All reads hit the cache first. On a miss, the caller fetches from Telegram
+ * and stores the result here. All writes invalidate or update the relevant key.
+ *
+ * The cache also stores the "collection index" — the full key→msgId map for
+ * each collection — so that single-document lookups are O(1) without scanning
+ * all messages.
+ */
+declare class HotCache extends EventEmitter {
+    private cache;
+    private collectionIndexes;
+    private stats;
+    constructor(maxBytes?: number, ttlMs?: number);
+    get<T>(collection: string, id: string): T | undefined;
+    set<T>(collection: string, id: string, data: T): void;
+    delete(collection: string, id: string): void;
+    invalidateCollection(collection: string): void;
+    getQuery<T>(queryHash: string): T[] | undefined;
+    setQuery<T>(queryHash: string, results: T[]): void;
+    invalidateQuery(collection: string): void;
+    getIndex(collection: string): Map<string, number> | undefined;
+    setIndex(collection: string, index: Map<string, number>): void;
+    updateIndexEntry(collection: string, id: string, msgId: number): void;
+    deleteIndexEntry(collection: string, id: string): void;
+    getMsgId(collection: string, id: string): number | undefined;
+    getMany<T>(collection: string, ids: string[]): Map<string, T>;
+    getStats(): {
+        size: number;
+        hitRate: number;
+        hits: number;
+        misses: number;
+        evictions: number;
+    };
+    clear(): void;
+    private docKey;
+}
+
+interface IndexMessage {
+    collection: string;
+    entries: Record<string, number>;
+    walSeq: number;
+    updatedAt: string;
+    msgId?: number;
+}
+/**
+ * TelegramStorage handles the raw read/write operations against Telegram channels.
+ *
+ * Each collection gets a "collection index message" (pinned or findable by tag)
+ * that maps document IDs to their Telegram message IDs.
+ *
+ * Documents are stored as JSON message text, optionally AES-256 encrypted.
+ * Files are stored via sendDocument/sendPhoto and referenced by Telegram file_id.
+ */
+declare class TelegramStorage {
+    private pool;
+    private defaultChannelId;
+    private debug;
+    private encryptionKey;
+    private indexMsgIds;
+    constructor(pool: BotWorkerPool, defaultChannelId: string, encryptionKey?: string, debug?: boolean);
+    loadIndex(collection: string, channelId?: string): Promise<IndexMessage>;
+    saveIndex(index: IndexMessage, channelId?: string): Promise<void>;
+    writeDocument(doc: GramoBaseDocument, channelId?: string): Promise<number>;
+    readDocument(msgId: number, channelId?: string): Promise<GramoBaseDocument | null>;
+    deleteDocument(msgId: number, channelId?: string): Promise<void>;
+    updateDocument(msgId: number, doc: GramoBaseDocument, channelId?: string): Promise<number>;
+    private writeChunked;
+    private readChunked;
+    uploadFile(data: Buffer, fileName: string, mimeType: string, channelId?: string): Promise<{
+        fileId: string;
+        msgId: number;
+    }>;
+    getFileUrl(fileId: string): Promise<string>;
+    private encrypt;
+    private decrypt;
+}
+
+/**
+ * Write-Ahead Log backed by a Telegram channel.
+ *
+ * Every mutation is written to the WAL channel as a message BEFORE it is
+ * applied to the main index. On startup, the WAL is replayed to recover
+ * any operations that didn't complete during a crash.
+ *
+ * Format of each WAL message:
+ *   { "__wal": true, seq: N, op: "INSERT"|..., collection, id, data, ts, checksum }
+ */
+declare class WriteAheadLog {
+    private pool;
+    private walChannelId;
+    private debug;
+    private seq;
+    private buffer;
+    private flushTimer;
+    private readonly FLUSH_INTERVAL_MS;
+    private readonly BUFFER_LIMIT;
+    constructor(pool: BotWorkerPool, walChannelId: string, debug?: boolean);
+    init(): Promise<void>;
+    /**
+     * Append an entry to the WAL buffer. Flushes immediately if buffer is full.
+     */
+    append(op: WalOpType, collection: string, id: string, data?: unknown): Promise<WalEntry>;
+    /**
+     * Flush buffered WAL entries to Telegram.
+     */
+    flush(): Promise<void>;
+    /**
+     * Replay all WAL entries since a given sequence number.
+     * Returns entries in order — the caller applies them to restore state.
+     */
+    replay(sinceSeq?: number): Promise<WalEntry[]>;
+    private scheduleFlush;
+    private checksum;
+    private verifyChecksum;
+    private chunk;
+    getCurrentSeq(): number;
+}
+
+type DocOf<T extends z.ZodType> = WithId<z.infer<T>>;
+/**
+ * Collection<T> is the main ORM interface.
+ *
+ * It provides a MongoDB-like API and handles:
+ *   - Schema validation via Zod
+ *   - Hot-cache reads (LRU in-memory)
+ *   - WAL writes before Telegram flush
+ *   - Index management (id → msgId map, stored as a pinned message)
+ *   - Filter/sort/skip/limit in memory after cache warm-up
+ */
+declare class Collection<T extends z.ZodType> {
+    private name;
+    private config;
+    private cache;
+    private storage;
+    private wal;
+    private channelId;
+    private indexLoaded;
+    constructor(name: string, config: CollectionConfig<T>, cache: HotCache, storage: TelegramStorage, wal: WriteAheadLog, defaultChannelId: string);
+    ensureIndexLoaded(): Promise<void>;
+    insertOne(data: z.infer<T>): Promise<DocOf<T>>;
+    insertMany(items: z.infer<T>[]): Promise<DocOf<T>[]>;
+    findById(id: string): Promise<DocOf<T> | null>;
+    findOne(filter?: Filter<z.infer<T>>): Promise<DocOf<T> | null>;
+    find(options?: FindOptions<z.infer<T>>): Promise<DocOf<T>[]>;
+    count(filter?: Filter<z.infer<T>>): Promise<number>;
+    updateOne(filter: Filter<z.infer<T>>, update: UpdateOperators<z.infer<T>>): Promise<DocOf<T> | null>;
+    updateMany(filter: Filter<z.infer<T>>, update: UpdateOperators<z.infer<T>>): Promise<DocOf<T>[]>;
+    findByIdAndUpdate(id: string, update: UpdateOperators<z.infer<T>>): Promise<DocOf<T> | null>;
+    private applyUpdate;
+    deleteOne(filter: Filter<z.infer<T>>): Promise<boolean>;
+    deleteMany(filter: Filter<z.infer<T>>): Promise<number>;
+    deleteById(id: string): Promise<boolean>;
+    private flushIndex;
+    private matchesFilter;
+    private applySort;
+    private applyProjection;
+    private hashQuery;
+    getName(): string;
+}
+
+declare const UserSchema: z.ZodObject<{
+    email: z.ZodString;
+    passwordHash: z.ZodString;
+    roles: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    passwordHash: string;
+    roles: string[];
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    email: string;
+    passwordHash: string;
+    createdAt: string;
+    updatedAt: string;
+    roles?: string[] | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+declare class GramoBaseAuth {
+    private users;
+    private config;
+    private readonly DEFAULT_ROUNDS;
+    private readonly resolvedSecret;
+    constructor(users: Collection<typeof UserSchema>, config: AuthConfig);
+    register(email: string, password: string, roles?: string[], metadata?: Record<string, unknown>): Promise<{
+        user: User;
+        session: Session;
+    }>;
+    login(email: string, password: string): Promise<{
+        user: User;
+        session: Session;
+    }>;
+    verifyToken(token: string): Session;
+    requireRole(session: Session, role: string): void;
+    requireAnyRole(session: Session, roles: string[]): void;
+    changePassword(userId: string, oldPassword: string, newPassword: string): Promise<void>;
+    resetPassword(userId: string, newPassword: string): Promise<void>;
+    getUserById(id: string): Promise<User | null>;
+    getUserByEmail(email: string): Promise<User | null>;
+    updateRoles(userId: string, roles: string[]): Promise<void>;
+    deleteUser(userId: string): Promise<void>;
+    private createSession;
+    private parseExpiry;
+    middleware(): (req: any, res: any, next: any) => any;
+    requireRoleMiddleware(role: string): (req: any, res: any, next: any) => void;
+}
+
+export { Collection as C, GramoBaseAuth as G };

package/dist/GramoBaseAuth-CHNn2_e5.d.cts

@@ -0,0 +1,218 @@
+import { z } from 'zod';
+import { B as BotWorkerPool, e as GramoBaseDocument, i as WalOpType, h as WalEntry, C as CollectionConfig, j as WithId, c as Filter, d as FindOptions, f as UpdateOperators, A as AuthConfig, g as User, S as Session } from './BotWorkerPool-9ndHQt2g.cjs';
+import EventEmitter from 'eventemitter3';
+
+/**
+ * HotCache is an in-memory LRU cache that sits in front of Telegram storage.
+ *
+ * All reads hit the cache first. On a miss, the caller fetches from Telegram
+ * and stores the result here. All writes invalidate or update the relevant key.
+ *
+ * The cache also stores the "collection index" — the full key→msgId map for
+ * each collection — so that single-document lookups are O(1) without scanning
+ * all messages.
+ */
+declare class HotCache extends EventEmitter {
+    private cache;
+    private collectionIndexes;
+    private stats;
+    constructor(maxBytes?: number, ttlMs?: number);
+    get<T>(collection: string, id: string): T | undefined;
+    set<T>(collection: string, id: string, data: T): void;
+    delete(collection: string, id: string): void;
+    invalidateCollection(collection: string): void;
+    getQuery<T>(queryHash: string): T[] | undefined;
+    setQuery<T>(queryHash: string, results: T[]): void;
+    invalidateQuery(collection: string): void;
+    getIndex(collection: string): Map<string, number> | undefined;
+    setIndex(collection: string, index: Map<string, number>): void;
+    updateIndexEntry(collection: string, id: string, msgId: number): void;
+    deleteIndexEntry(collection: string, id: string): void;
+    getMsgId(collection: string, id: string): number | undefined;
+    getMany<T>(collection: string, ids: string[]): Map<string, T>;
+    getStats(): {
+        size: number;
+        hitRate: number;
+        hits: number;
+        misses: number;
+        evictions: number;
+    };
+    clear(): void;
+    private docKey;
+}
+
+interface IndexMessage {
+    collection: string;
+    entries: Record<string, number>;
+    walSeq: number;
+    updatedAt: string;
+    msgId?: number;
+}
+/**
+ * TelegramStorage handles the raw read/write operations against Telegram channels.
+ *
+ * Each collection gets a "collection index message" (pinned or findable by tag)
+ * that maps document IDs to their Telegram message IDs.
+ *
+ * Documents are stored as JSON message text, optionally AES-256 encrypted.
+ * Files are stored via sendDocument/sendPhoto and referenced by Telegram file_id.
+ */
+declare class TelegramStorage {
+    private pool;
+    private defaultChannelId;
+    private debug;
+    private encryptionKey;
+    private indexMsgIds;
+    constructor(pool: BotWorkerPool, defaultChannelId: string, encryptionKey?: string, debug?: boolean);
+    loadIndex(collection: string, channelId?: string): Promise<IndexMessage>;
+    saveIndex(index: IndexMessage, channelId?: string): Promise<void>;
+    writeDocument(doc: GramoBaseDocument, channelId?: string): Promise<number>;
+    readDocument(msgId: number, channelId?: string): Promise<GramoBaseDocument | null>;
+    deleteDocument(msgId: number, channelId?: string): Promise<void>;
+    updateDocument(msgId: number, doc: GramoBaseDocument, channelId?: string): Promise<number>;
+    private writeChunked;
+    private readChunked;
+    uploadFile(data: Buffer, fileName: string, mimeType: string, channelId?: string): Promise<{
+        fileId: string;
+        msgId: number;
+    }>;
+    getFileUrl(fileId: string): Promise<string>;
+    private encrypt;
+    private decrypt;
+}
+
+/**
+ * Write-Ahead Log backed by a Telegram channel.
+ *
+ * Every mutation is written to the WAL channel as a message BEFORE it is
+ * applied to the main index. On startup, the WAL is replayed to recover
+ * any operations that didn't complete during a crash.
+ *
+ * Format of each WAL message:
+ *   { "__wal": true, seq: N, op: "INSERT"|..., collection, id, data, ts, checksum }
+ */
+declare class WriteAheadLog {
+    private pool;
+    private walChannelId;
+    private debug;
+    private seq;
+    private buffer;
+    private flushTimer;
+    private readonly FLUSH_INTERVAL_MS;
+    private readonly BUFFER_LIMIT;
+    constructor(pool: BotWorkerPool, walChannelId: string, debug?: boolean);
+    init(): Promise<void>;
+    /**
+     * Append an entry to the WAL buffer. Flushes immediately if buffer is full.
+     */
+    append(op: WalOpType, collection: string, id: string, data?: unknown): Promise<WalEntry>;
+    /**
+     * Flush buffered WAL entries to Telegram.
+     */
+    flush(): Promise<void>;
+    /**
+     * Replay all WAL entries since a given sequence number.
+     * Returns entries in order — the caller applies them to restore state.
+     */
+    replay(sinceSeq?: number): Promise<WalEntry[]>;
+    private scheduleFlush;
+    private checksum;
+    private verifyChecksum;
+    private chunk;
+    getCurrentSeq(): number;
+}
+
+type DocOf<T extends z.ZodType> = WithId<z.infer<T>>;
+/**
+ * Collection<T> is the main ORM interface.
+ *
+ * It provides a MongoDB-like API and handles:
+ *   - Schema validation via Zod
+ *   - Hot-cache reads (LRU in-memory)
+ *   - WAL writes before Telegram flush
+ *   - Index management (id → msgId map, stored as a pinned message)
+ *   - Filter/sort/skip/limit in memory after cache warm-up
+ */
+declare class Collection<T extends z.ZodType> {
+    private name;
+    private config;
+    private cache;
+    private storage;
+    private wal;
+    private channelId;
+    private indexLoaded;
+    constructor(name: string, config: CollectionConfig<T>, cache: HotCache, storage: TelegramStorage, wal: WriteAheadLog, defaultChannelId: string);
+    ensureIndexLoaded(): Promise<void>;
+    insertOne(data: z.infer<T>): Promise<DocOf<T>>;
+    insertMany(items: z.infer<T>[]): Promise<DocOf<T>[]>;
+    findById(id: string): Promise<DocOf<T> | null>;
+    findOne(filter?: Filter<z.infer<T>>): Promise<DocOf<T> | null>;
+    find(options?: FindOptions<z.infer<T>>): Promise<DocOf<T>[]>;
+    count(filter?: Filter<z.infer<T>>): Promise<number>;
+    updateOne(filter: Filter<z.infer<T>>, update: UpdateOperators<z.infer<T>>): Promise<DocOf<T> | null>;
+    updateMany(filter: Filter<z.infer<T>>, update: UpdateOperators<z.infer<T>>): Promise<DocOf<T>[]>;
+    findByIdAndUpdate(id: string, update: UpdateOperators<z.infer<T>>): Promise<DocOf<T> | null>;
+    private applyUpdate;
+    deleteOne(filter: Filter<z.infer<T>>): Promise<boolean>;
+    deleteMany(filter: Filter<z.infer<T>>): Promise<number>;
+    deleteById(id: string): Promise<boolean>;
+    private flushIndex;
+    private matchesFilter;
+    private applySort;
+    private applyProjection;
+    private hashQuery;
+    getName(): string;
+}
+
+declare const UserSchema: z.ZodObject<{
+    email: z.ZodString;
+    passwordHash: z.ZodString;
+    roles: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    passwordHash: string;
+    roles: string[];
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    email: string;
+    passwordHash: string;
+    createdAt: string;
+    updatedAt: string;
+    roles?: string[] | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+declare class GramoBaseAuth {
+    private users;
+    private config;
+    private readonly DEFAULT_ROUNDS;
+    private readonly resolvedSecret;
+    constructor(users: Collection<typeof UserSchema>, config: AuthConfig);
+    register(email: string, password: string, roles?: string[], metadata?: Record<string, unknown>): Promise<{
+        user: User;
+        session: Session;
+    }>;
+    login(email: string, password: string): Promise<{
+        user: User;
+        session: Session;
+    }>;
+    verifyToken(token: string): Session;
+    requireRole(session: Session, role: string): void;
+    requireAnyRole(session: Session, roles: string[]): void;
+    changePassword(userId: string, oldPassword: string, newPassword: string): Promise<void>;
+    resetPassword(userId: string, newPassword: string): Promise<void>;
+    getUserById(id: string): Promise<User | null>;
+    getUserByEmail(email: string): Promise<User | null>;
+    updateRoles(userId: string, roles: string[]): Promise<void>;
+    deleteUser(userId: string): Promise<void>;
+    private createSession;
+    private parseExpiry;
+    middleware(): (req: any, res: any, next: any) => any;
+    requireRoleMiddleware(role: string): (req: any, res: any, next: any) => void;
+}
+
+export { Collection as C, GramoBaseAuth as G };