mondoo 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,3249 @@
+import { ObjectId } from 'mondodb';
+export { ObjectId } from 'mondodb';
+
+/**
+ * Core types for Mondoo
+ */
+
+/**
+ * Schema type markers for type inference
+ */
+interface SchemaTypeOptions<T = unknown> {
+    type?: T;
+    required?: boolean;
+    default?: T | (() => T);
+    validate?: ((value: T) => boolean | Promise<boolean>) | RegExp;
+    enum?: readonly T[];
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    match?: RegExp;
+    ref?: string;
+    index?: boolean;
+    unique?: boolean;
+    sparse?: boolean;
+}
+/**
+ * Base schema type - all schema types extend this
+ */
+declare abstract class SchemaType<T, Required extends boolean = false> {
+    abstract readonly _type: T;
+    abstract readonly _required: Required;
+    protected _options: SchemaTypeOptions<T>;
+    protected _validators: Array<(value: T) => boolean | Promise<boolean>>;
+    required(): SchemaType<T, true>;
+    default(value: T | (() => T)): this;
+    validate(fn: (value: T) => boolean | Promise<boolean>): this;
+    index(value?: boolean): this;
+    unique(value?: boolean): this;
+    protected abstract _clone(): this;
+    /** @internal */
+    _getOptions(): SchemaTypeOptions<T>;
+    /** @internal */
+    _getValidators(): Array<(value: T) => boolean | Promise<boolean>>;
+    /** @internal */
+    abstract _cast(value: unknown): T;
+    /** @internal */
+    _validate(value: T): Promise<boolean>;
+}
+/**
+ * String schema type
+ */
+declare class StringType<R extends boolean = false> extends SchemaType<string, R> {
+    readonly _type: string;
+    readonly _required: R;
+    protected _clone(): this;
+    _cast(value: unknown): string;
+    email(): this;
+    url(): this;
+    uuid(): this;
+    regex(pattern: RegExp): this;
+    min(length: number): this;
+    max(length: number): this;
+    length(len: number): this;
+    trim(): this;
+    lowercase(): this;
+    uppercase(): this;
+}
+/**
+ * Number schema type
+ */
+declare class NumberType<R extends boolean = false> extends SchemaType<number, R> {
+    readonly _type: number;
+    readonly _required: R;
+    protected _clone(): this;
+    _cast(value: unknown): number;
+    min(value: number): this;
+    max(value: number): this;
+    int(): this;
+    positive(): this;
+    negative(): this;
+    finite(): this;
+}
+/**
+ * Boolean schema type
+ */
+declare class BooleanType<R extends boolean = false> extends SchemaType<boolean, R> {
+    readonly _type: boolean;
+    readonly _required: R;
+    protected _clone(): this;
+    _cast(value: unknown): boolean;
+}
+/**
+ * Date schema type
+ */
+declare class DateType<R extends boolean = false> extends SchemaType<Date, R> {
+    readonly _type: Date;
+    readonly _required: R;
+    protected _clone(): this;
+    _cast(value: unknown): Date;
+    min(date: Date | string | number): this;
+    max(date: Date | string | number): this;
+}
+/**
+ * ObjectId schema type with ref support
+ */
+declare class ObjectIdType<R extends boolean = false, RefModel extends string = never> extends SchemaType<ObjectId, R> {
+    readonly _type: ObjectId;
+    readonly _required: R;
+    readonly _ref: RefModel;
+    protected _clone(): this;
+    _cast(value: unknown): ObjectId;
+    _validate(value: ObjectId): Promise<boolean>;
+    ref<M extends string>(model: M): ObjectIdType<R, M>;
+}
+/**
+ * Array schema type
+ */
+declare class ArrayType<T, R extends boolean = false> extends SchemaType<T[], R> {
+    readonly _type: T[];
+    readonly _required: R;
+    readonly _itemType: SchemaType<T, any>;
+    constructor(itemType: SchemaType<T, any>);
+    protected _clone(): this;
+    _cast(value: unknown): T[];
+    _validate(value: T[]): Promise<boolean>;
+    min(length: number): this;
+    max(length: number): this;
+    length(len: number): this;
+    nonempty(): this;
+}
+/**
+ * Object schema type for nested schemas
+ */
+declare class ObjectType<T extends Record<string, SchemaType<any, any>>, R extends boolean = false> extends SchemaType<InferObject<T>, R> {
+    readonly _type: InferObject<T>;
+    readonly _required: R;
+    readonly _shape: T;
+    constructor(shape: T);
+    protected _clone(): this;
+    _cast(value: unknown): InferObject<T>;
+}
+/**
+ * Enum schema type
+ */
+declare class EnumType<T extends readonly string[], R extends boolean = false> extends SchemaType<T[number], R> {
+    readonly _type: T[number];
+    readonly _required: R;
+    readonly _values: T;
+    constructor(values: T);
+    protected _clone(): this;
+    _cast(value: unknown): T[number];
+    _validate(value: T[number]): Promise<boolean>;
+}
+/**
+ * Literal schema type
+ */
+declare class LiteralType<T extends string | number | boolean, R extends boolean = false> extends SchemaType<T, R> {
+    readonly _type: T;
+    readonly _required: R;
+    readonly _value: T;
+    constructor(value: T);
+    protected _clone(): this;
+    _cast(value: unknown): T;
+    _validate(value: T): Promise<boolean>;
+}
+/**
+ * Map schema type
+ */
+declare class MapType<T, R extends boolean = false> extends SchemaType<Map<string, T>, R> {
+    readonly _type: Map<string, T>;
+    readonly _required: R;
+    readonly _valueType: SchemaType<T, any>;
+    constructor(valueType: SchemaType<T, any>);
+    protected _clone(): this;
+    _cast(value: unknown): Map<string, T>;
+    _validate(value: Map<string, T> | Record<string, T>): Promise<boolean>;
+}
+/**
+ * Mixed/Any schema type
+ */
+declare class MixedType<R extends boolean = false> extends SchemaType<unknown, R> {
+    readonly _type: unknown;
+    readonly _required: R;
+    protected _clone(): this;
+    _cast(value: unknown): unknown;
+}
+/**
+ * Buffer schema type
+ */
+declare class BufferType<R extends boolean = false> extends SchemaType<ArrayBuffer, R> {
+    readonly _type: ArrayBuffer;
+    readonly _required: R;
+    protected _clone(): this;
+    _cast(value: unknown): ArrayBuffer;
+}
+/**
+ * BigInt schema type
+ */
+declare class BigIntType<R extends boolean = false> extends SchemaType<bigint, R> {
+    readonly _type: bigint;
+    readonly _required: R;
+    protected _clone(): this;
+    _cast(value: unknown): bigint;
+}
+/**
+ * Infer the TypeScript type from a SchemaType
+ */
+type InferSchemaType<T> = T extends SchemaType<infer V, infer R> ? R extends true ? V : V | undefined : never;
+/**
+ * Infer object type from object shape
+ */
+type InferObject<T extends Record<string, SchemaType<any, any>>> = {
+    [K in keyof T as T[K] extends SchemaType<any, true> ? K : never]: InferSchemaType<T[K]>;
+} & {
+    [K in keyof T as T[K] extends SchemaType<any, true> ? never : K]?: InferSchemaType<T[K]>;
+};
+/**
+ * Infer the full document type from a schema shape
+ */
+type InferSchema<T extends Record<string, SchemaType<any, any>>> = InferObject<T> & {
+    _id: ObjectId;
+};
+/**
+ * Transform populated paths - replace ObjectId refs with actual documents
+ */
+type PopulatedDoc<T, Paths extends keyof T = never> = {
+    [K in keyof T]: K extends Paths ? T[K] extends ObjectId | undefined ? unknown : T[K] extends (ObjectId | undefined)[] ? unknown[] : T[K] : T[K];
+};
+
+/**
+ * Schema class - supports both Mongoose-style and $-style definitions
+ */
+
+declare const Types: {
+    String: StringConstructor;
+    Number: NumberConstructor;
+    Boolean: BooleanConstructor;
+    Date: DateConstructor;
+    ObjectId: "ObjectId";
+    Buffer: "Buffer";
+    Mixed: "Mixed";
+    Array: ArrayConstructor;
+    Map: MapConstructor;
+    BigInt: BigIntConstructor;
+};
+type MongooseFieldDef = typeof String | typeof Number | typeof Boolean | typeof Date | 'ObjectId' | 'Buffer' | 'Mixed' | typeof BigInt | MongooseFieldDefObject | [MongooseFieldDef] | SchemaType<any, any>;
+interface MongooseFieldDefObject {
+    type?: MongooseFieldDef;
+    required?: boolean;
+    default?: unknown;
+    validate?: ((value: any) => boolean | Promise<boolean>) | RegExp;
+    enum?: readonly string[];
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    match?: RegExp;
+    ref?: string;
+    index?: boolean;
+    unique?: boolean;
+    sparse?: boolean;
+    select?: boolean;
+    immutable?: boolean;
+    transform?: (value: any) => any;
+}
+type SchemaDefinition = Record<string, MongooseFieldDef>;
+interface SchemaOptions$1 {
+    timestamps?: boolean | {
+        createdAt?: string | boolean;
+        updatedAt?: string | boolean;
+    };
+    versionKey?: boolean | string;
+    strict?: boolean | 'throw';
+    collection?: string;
+    discriminatorKey?: string;
+    autoIndex?: boolean;
+    minimize?: boolean;
+    toJSON?: {
+        virtuals?: boolean;
+        getters?: boolean;
+        transform?: Function;
+    };
+    toObject?: {
+        virtuals?: boolean;
+        getters?: boolean;
+        transform?: Function;
+    };
+    id?: boolean;
+    _id?: boolean;
+}
+type HookType = 'validate' | 'save' | 'remove' | 'deleteOne' | 'updateOne' | 'init' | 'find' | 'findOne' | 'findOneAndUpdate' | 'findOneAndDelete' | 'findOneAndReplace' | 'updateMany' | 'deleteMany' | 'aggregate' | 'insertMany';
+type PreHookFn<T = any> = (this: T, next: (err?: Error) => void) => void | Promise<void>;
+type PostHookFn<T = any, R = any> = (this: T, doc: R, next: (err?: Error) => void) => void | Promise<void>;
+interface MiddlewareEntry$1 {
+    fn: Function;
+    options?: {
+        document?: boolean;
+        query?: boolean;
+    };
+}
+interface VirtualType<T = any> {
+    get?: (this: T) => any;
+    set?: (this: T, value: any) => void;
+    options?: {
+        ref?: string;
+        localField?: string;
+        foreignField?: string;
+        justOne?: boolean;
+    };
+}
+declare class Schema<T = any> {
+    private _definition;
+    private _options;
+    private _paths;
+    private _methods;
+    private _statics;
+    private _virtuals;
+    private _preHooks;
+    private _postHooks;
+    private _indexes;
+    private _plugins;
+    /**
+     * Mongoose-style constructor
+     */
+    constructor(definition?: SchemaDefinition, options?: SchemaOptions$1);
+    /**
+     * Create schema from $-style definition
+     */
+    static fromZodStyle<T extends Record<string, SchemaType<any, any>>>(shape: T, options?: SchemaOptions$1): Schema<InferObject<T>>;
+    /**
+     * Parse Mongoose-style definition into SchemaTypes
+     */
+    private _parseDefinition;
+    /**
+     * Parse a single field definition
+     */
+    private _parseField;
+    /**
+     * Add a path to the schema
+     */
+    add(definition: SchemaDefinition | Record<string, SchemaType<any, any>>, prefix?: string): this;
+    /**
+     * Get a path's SchemaType
+     */
+    path(path: string): SchemaType<any, any> | undefined;
+    /**
+     * Get all paths
+     */
+    paths(): Map<string, SchemaType<any, any>>;
+    /**
+     * Iterate over all paths (Mongoose-compatible)
+     */
+    eachPath(fn: (path: string, type: SchemaType<any, any>) => void): void;
+    /**
+     * Check if path exists
+     */
+    pathType(path: string): 'real' | 'virtual' | 'nested' | 'adhocOrUndefined';
+    /**
+     * Get required paths
+     */
+    requiredPaths(): string[];
+    /**
+     * Clone the schema
+     */
+    clone(): Schema<T>;
+    /**
+     * Add an instance method
+     */
+    method(name: string, fn: Function): this;
+    method(methods: Record<string, Function>): this;
+    /**
+     * Get instance methods (Mongoose-compatible property)
+     */
+    get methods(): Record<string, Function>;
+    /**
+     * Add a static method
+     */
+    static(name: string, fn: Function): this;
+    static(statics: Record<string, Function>): this;
+    /**
+     * Get static methods (Mongoose-compatible property)
+     */
+    get statics(): Record<string, Function>;
+    /**
+     * Add a virtual property
+     */
+    virtual(name: string, options?: VirtualType['options']): VirtualBuilder;
+    /**
+     * Get virtuals
+     */
+    virtuals(): Map<string, VirtualType>;
+    /**
+     * Add pre middleware
+     */
+    pre<K extends HookType>(hook: K | K[], options: {
+        document?: boolean;
+        query?: boolean;
+    } | PreHookFn, fn?: PreHookFn): this;
+    /**
+     * Add post middleware
+     */
+    post<K extends HookType>(hook: K | K[], options: {
+        document?: boolean;
+        query?: boolean;
+    } | PostHookFn, fn?: PostHookFn): this;
+    /**
+     * Get pre hooks for a specific operation
+     */
+    getPreHooks(hook: HookType): MiddlewareEntry$1[];
+    /**
+     * Get post hooks for a specific operation
+     */
+    getPostHooks(hook: HookType): MiddlewareEntry$1[];
+    /**
+     * Add an index
+     */
+    index(fields: Record<string, 1 | -1 | 'text' | '2dsphere'>, options?: Record<string, any>): this;
+    /**
+     * Get all indexes (Mongoose-compatible format: [fields, options][])
+     */
+    indexes(): Array<[Record<string, 1 | -1>, Record<string, any> | undefined]>;
+    /**
+     * Apply a plugin
+     */
+    plugin(fn: (schema: Schema<T>, options?: any) => void, options?: any): this;
+    /**
+     * Schema options (Mongoose-compatible property)
+     */
+    get options(): SchemaOptions$1;
+    /**
+     * Original schema definition (Mongoose-compatible property)
+     */
+    get obj(): SchemaDefinition;
+    /**
+     * Get/set schema options
+     */
+    set<K extends keyof SchemaOptions$1>(key: K, value: SchemaOptions$1[K]): this;
+    set(options: SchemaOptions$1): this;
+    get<K extends keyof SchemaOptions$1>(key: K): SchemaOptions$1[K];
+    /**
+     * Validate a document against this schema
+     */
+    validate(doc: Record<string, unknown>): Promise<{
+        valid: boolean;
+        errors: ValidationError[];
+    }>;
+    /**
+     * Cast a document to schema types
+     */
+    cast(doc: Record<string, unknown>): T;
+}
+declare class VirtualBuilder {
+    private virtual;
+    constructor(virtual: VirtualType);
+    get(fn: () => any): this;
+    set(fn: (value: any) => void): this;
+}
+interface ValidationError {
+    path: string;
+    message: string;
+    kind: string;
+    value: unknown;
+}
+declare class MongooseValidationError extends Error {
+    errors: Map<string, ValidationError>;
+    constructor(message?: string);
+    addError(path: string, error: ValidationError): void;
+}
+
+/**
+ * The $ namespace - Zod-style API for Mondoo
+ *
+ * @example
+ * ```typescript
+ * import { $ } from 'mondoo'
+ *
+ * const userSchema = $.schema({
+ *   name: $.string().required(),
+ *   email: $.string().email(),
+ *   age: $.number().min(0).max(150),
+ *   role: $.enum(['admin', 'user', 'guest']),
+ *   posts: $.array($.objectId().ref('Post'))
+ * })
+ *
+ * type User = $.infer<typeof userSchema>
+ * ```
+ */
+
+type InferHelper = <T extends Schema<any>>() => T extends Schema<infer U> ? U : never;
+interface SchemaOptions {
+    timestamps?: boolean;
+    versionKey?: boolean | string;
+    strict?: boolean | 'throw';
+    collection?: string;
+    discriminatorKey?: string;
+}
+/**
+ * The $ namespace - TypeScript-first schema builder
+ */
+declare const $: {
+    /**
+     * Create a string schema type
+     * @example $.string().email().required()
+     */
+    string: () => StringType<false>;
+    /**
+     * Create a number schema type
+     * @example $.number().min(0).max(100)
+     */
+    number: () => NumberType<false>;
+    /**
+     * Create a boolean schema type
+     */
+    boolean: () => BooleanType<false>;
+    /**
+     * Create a date schema type
+     * @example $.date().min(new Date('2020-01-01'))
+     */
+    date: () => DateType<false>;
+    /**
+     * Create an ObjectId schema type
+     * @example $.objectId().ref('User')
+     */
+    objectId: () => ObjectIdType<false, never>;
+    /**
+     * Create a buffer/binary schema type
+     */
+    buffer: () => BufferType<false>;
+    /**
+     * Create a bigint schema type
+     */
+    bigint: () => BigIntType<false>;
+    /**
+     * Create an array schema type
+     * @example $.array($.string())
+     */
+    array: <T>(itemType: SchemaType<T, any>) => ArrayType<T, false>;
+    /**
+     * Create a nested object schema type
+     * @example $.object({ name: $.string(), age: $.number() })
+     */
+    object: <T extends Record<string, SchemaType<any, any>>>(shape: T) => ObjectType<T, false>;
+    /**
+     * Create a map schema type (string keys, typed values)
+     * @example $.map($.number())
+     */
+    map: <T>(valueType: SchemaType<T, any>) => MapType<T, false>;
+    /**
+     * Create an enum schema type
+     * @example $.enum(['admin', 'user', 'guest'])
+     */
+    enum: <T extends readonly string[]>(values: T) => EnumType<T, false>;
+    /**
+     * Create a literal schema type
+     * @example $.literal('active')
+     */
+    literal: <T extends string | number | boolean>(value: T) => LiteralType<T, false>;
+    /**
+     * Create a mixed/any schema type (no type checking)
+     */
+    mixed: () => MixedType<false>;
+    /**
+     * Alias for mixed()
+     */
+    any: () => MixedType<false>;
+    /**
+     * Create a new schema from a shape definition
+     * @example
+     * ```typescript
+     * const userSchema = $.schema({
+     *   name: $.string().required(),
+     *   email: $.string().email()
+     * })
+     * ```
+     */
+    schema: <T extends Record<string, SchemaType<any, any>>>(shape: T, options?: SchemaOptions) => Schema<InferObject<T>>;
+    /**
+     * Infer TypeScript type from schema (compile-time only)
+     * @example type User = $.infer<typeof userSchema>
+     */
+    infer: InferHelper;
+    /**
+     * Infer input type (before transforms)
+     */
+    input: InferHelper;
+    /**
+     * Infer output type (after transforms)
+     */
+    output: InferHelper;
+};
+type $ = typeof $;
+
+/**
+ * Document class - represents a single MongoDB document with change tracking
+ */
+
+/**
+ * Internal document state for tracking changes and metadata
+ */
+interface DocumentInternal {
+    /** Set of paths that have been modified */
+    modifiedPaths: Set<string>;
+    /** Whether this is a new document (not yet saved) */
+    isNew: boolean;
+    /** Original values before modification (for dirty checking) */
+    originalValues: Map<string, unknown>;
+    /** Paths that have been populated with referenced documents */
+    populated: Map<string, ObjectId | ObjectId[]>;
+    /** Transaction session */
+    session: unknown | null;
+    /** Whether the document has been deleted */
+    wasDeleted: boolean;
+    /** Validation errors */
+    validationError: MongooseValidationError | null;
+    /** Paths that were explicitly marked as modified */
+    directModifiedPaths: Set<string>;
+    /** The schema for this document */
+    schema: Schema<any> | null;
+    /** Reference to the Model (will be set by Model class) */
+    model: any | null;
+    /** Version key value */
+    version: number;
+    /** Paths to select (projection) */
+    selected?: Record<string, 0 | 1>;
+    /** Whether strict mode is enabled */
+    strictMode: boolean | 'throw';
+}
+interface ToObjectOptions {
+    /** Include getters in output */
+    getters?: boolean;
+    /** Include virtuals in output */
+    virtuals?: boolean;
+    /** Include version key */
+    versionKey?: boolean;
+    /** Transform function */
+    transform?: (doc: Document<any>, ret: Record<string, unknown>, options: ToObjectOptions) => Record<string, unknown>;
+    /** Depopulate refs */
+    depopulate?: boolean;
+    /** Minimize output (remove empty objects) */
+    minimize?: boolean;
+    /** Flatten maps to plain objects */
+    flattenMaps?: boolean;
+    /** Use aliases */
+    aliases?: boolean;
+}
+/**
+ * Document class with Proxy-based change tracking
+ */
+declare class Document<T extends Record<string, unknown> = Record<string, unknown>> {
+    /** Internal document data storage */
+    _doc: T;
+    /** Internal state object */
+    $__: DocumentInternal;
+    /** Whether this document is new (not yet saved to database) */
+    get isNew(): boolean;
+    set isNew(value: boolean);
+    /** Whether this document has been deleted */
+    $isDeleted: boolean;
+    /** The document's _id */
+    get _id(): ObjectId | undefined;
+    set _id(value: ObjectId | undefined);
+    /** The document's id as a string */
+    get id(): string | undefined;
+    /**
+     * Create a new Document instance
+     */
+    constructor(doc?: Partial<T>, schema?: Schema<T>, isNew?: boolean);
+    /**
+     * Create a Proxy wrapper for change tracking
+     */
+    private _createProxy;
+    /**
+     * Mark a path as modified
+     */
+    markModified(path: string): this;
+    /**
+     * Check if a path (or any path if not specified) has been modified
+     */
+    isModified(path?: string | string[]): boolean;
+    /**
+     * Get all modified paths
+     */
+    modifiedPaths(options?: {
+        includeChildren?: boolean;
+    }): string[];
+    /**
+     * Get paths that were directly modified (not parent paths)
+     */
+    directModifiedPaths(): string[];
+    /**
+     * Helper to get nested paths from an object
+     */
+    private _getNestedPaths;
+    /**
+     * Unmark a path as modified
+     */
+    unmarkModified(path: string): this;
+    /**
+     * Check if document is selected for a path
+     */
+    isSelected(path: string): boolean;
+    /**
+     * Check if document is initialized
+     */
+    isInit(path: string): boolean;
+    /**
+     * Save the document to the database
+     * Note: This is a placeholder - actual implementation will be in Model
+     */
+    save(options?: {
+        validateBeforeSave?: boolean;
+        session?: unknown;
+    }): Promise<this>;
+    /**
+     * Run schema validators on this document
+     */
+    validate(pathsToValidate?: string[]): Promise<void>;
+    /**
+     * Validate a specific path synchronously
+     * Note: This is named for Mongoose compatibility but may not support async validators
+     */
+    validateSync(paths?: string[]): ValidationError[] | null;
+    /**
+     * Get the validation error for this document
+     */
+    get errors(): Map<string, ValidationError> | undefined;
+    /**
+     * Convert document to a plain JavaScript object
+     */
+    toObject(options?: ToObjectOptions): Record<string, unknown>;
+    /**
+     * Convert document to JSON
+     */
+    toJSON(options?: ToObjectOptions): Record<string, unknown>;
+    /**
+     * Helper to minimize an object (remove empty nested objects)
+     */
+    private _minimize;
+    /**
+     * Helper to flatten Maps to plain objects
+     */
+    private _flattenMaps;
+    /**
+     * Get a value by path (supports dot notation)
+     */
+    get(path: string, type?: any): unknown;
+    /**
+     * Set a value by path (supports dot notation) with change tracking
+     */
+    set(path: string | Record<string, unknown>, val?: unknown): this;
+    /**
+     * Helper to set a nested value by path
+     */
+    private _setNestedValue;
+    /**
+     * Populate referenced documents
+     * Note: This is a placeholder - actual implementation requires Model
+     */
+    populate(path: string | string[] | Record<string, any>): Promise<this>;
+    /**
+     * Get the original ObjectId for a populated path
+     */
+    populated(path: string): ObjectId | ObjectId[] | undefined;
+    /**
+     * Restore the original ObjectId for a populated path
+     */
+    depopulate(path?: string): this;
+    /**
+     * Mark a path as populated with the original ObjectId
+     * @internal
+     */
+    _markPopulated(path: string, originalId: ObjectId | ObjectId[]): void;
+    /**
+     * Get or set the transaction session
+     */
+    $session(): unknown | null;
+    $session(session: unknown | null): this;
+    /**
+     * Get a specific field's value (alias for get)
+     */
+    $get(path: string): unknown;
+    /**
+     * Set a specific field's value (alias for set)
+     */
+    $set(path: string | Record<string, unknown>, val?: unknown): this;
+    /**
+     * Check if a path exists in the document
+     */
+    $has(path: string): boolean;
+    /**
+     * Delete a path from the document
+     */
+    $unset(path: string | string[]): this;
+    /**
+     * Increment a numeric field
+     */
+    $inc(path: string, val?: number): this;
+    /**
+     * Check equality with another document or object
+     */
+    equals(doc: Document<T> | Record<string, unknown>): boolean;
+    /**
+     * Get the document's schema
+     */
+    get schema(): Schema<T> | null;
+    /**
+     * Get the document's model name
+     */
+    get modelName(): string | undefined;
+    /**
+     * Get the collection for this document
+     */
+    get collection(): unknown | undefined;
+    /**
+     * Get the database for this document
+     */
+    get db(): unknown | undefined;
+    /**
+     * Override for Array.isArray checks
+     */
+    get [Symbol.toStringTag](): string;
+    /**
+     * Create a copy of this document
+     */
+    $clone(): Document<T>;
+    /**
+     * Reset all modifications
+     */
+    $reset(): this;
+    /**
+     * Mark document as deleted
+     */
+    $markDeleted(val?: boolean): void;
+    /**
+     * Check if document was deleted
+     */
+    $wasDeleted(): boolean;
+    /**
+     * Get parent document (for subdocuments)
+     */
+    parent(): Document<any> | undefined;
+    /**
+     * Get root document (for nested subdocuments)
+     */
+    $root(): Document<any>;
+    /**
+     * Remove this document from the database
+     * Note: Placeholder - actual implementation in Model
+     */
+    deleteOne(options?: {
+        session?: unknown;
+    }): Promise<this>;
+    /**
+     * Alias for deleteOne
+     */
+    remove(options?: {
+        session?: unknown;
+    }): Promise<this>;
+    /**
+     * Update this document
+     * Note: Placeholder - actual implementation in Model
+     */
+    updateOne(update: Record<string, unknown>, options?: {
+        session?: unknown;
+    }): Promise<unknown>;
+    /**
+     * Overwrite this document's data
+     */
+    overwrite(obj: Partial<T>): this;
+    /**
+     * Replaces current document with another
+     */
+    $replaceWith(replacement: Partial<T>): this;
+    /**
+     * Inspect for console logging
+     */
+    inspect(): Record<string, unknown>;
+}
+
+/**
+ * Query Builder - Chainable query construction for Mondoo
+ *
+ * @example
+ * ```typescript
+ * // Basic query
+ * const users = await User.find({ age: { $gte: 18 } })
+ *
+ * // Chained query
+ * const users = await User
+ *   .find()
+ *   .where('age').gte(18)
+ *   .where('role').in(['admin', 'user'])
+ *   .select('name email')
+ *   .sort({ createdAt: -1 })
+ *   .limit(10)
+ *   .lean()
+ * ```
+ */
+/**
+ * Query operation types
+ */
+type QueryOperation = 'find' | 'findOne' | 'findOneAndUpdate' | 'findOneAndDelete' | 'findOneAndReplace' | 'updateOne' | 'updateMany' | 'deleteOne' | 'deleteMany' | 'count' | 'countDocuments' | 'estimatedDocumentCount' | 'distinct';
+/**
+ * Filter operators for queries
+ */
+interface FilterOperators<T = unknown> {
+    $eq?: T;
+    $ne?: T;
+    $gt?: T;
+    $gte?: T;
+    $lt?: T;
+    $lte?: T;
+    $in?: T[];
+    $nin?: T[];
+    $exists?: boolean;
+    $regex?: RegExp | string;
+    $not?: FilterOperators<T>;
+    $elemMatch?: Record<string, unknown>;
+    $size?: number;
+    $all?: T[];
+    $type?: string | number;
+    $mod?: [number, number];
+}
+/**
+ * Root query filter type
+ */
+type FilterQuery<T> = {
+    [P in keyof T]?: T[P] | FilterOperators<T[P]>;
+} & {
+    $and?: FilterQuery<T>[];
+    $or?: FilterQuery<T>[];
+    $nor?: FilterQuery<T>[];
+    $not?: FilterQuery<T>;
+    $text?: {
+        $search: string;
+        $language?: string;
+        $caseSensitive?: boolean;
+    };
+    $where?: string | Function;
+    $comment?: string;
+};
+/**
+ * Population options
+ */
+interface PopulateOptions$1 {
+    path: string;
+    select?: string | string[] | Record<string, 0 | 1>;
+    match?: Record<string, unknown>;
+    model?: string;
+    options?: QueryOptions;
+    populate?: PopulateOptions$1 | PopulateOptions$1[] | string;
+    justOne?: boolean;
+    localField?: string;
+    foreignField?: string;
+}
+/**
+ * Query options (sort, skip, limit, etc.)
+ */
+interface QueryOptions {
+    lean?: boolean;
+    populate?: string | string[] | PopulateOptions$1 | PopulateOptions$1[];
+    select?: string | Record<string, 0 | 1>;
+    sort?: string | Record<string, 1 | -1 | 'asc' | 'desc'>;
+    limit?: number;
+    skip?: number;
+    projection?: Record<string, 0 | 1>;
+    new?: boolean;
+    upsert?: boolean;
+    session?: unknown;
+    timestamps?: boolean;
+    strict?: boolean;
+    batchSize?: number;
+    collation?: {
+        locale: string;
+        caseLevel?: boolean;
+        caseFirst?: 'upper' | 'lower' | 'off';
+        strength?: 1 | 2 | 3 | 4 | 5;
+        numericOrdering?: boolean;
+        alternate?: 'non-ignorable' | 'shifted';
+        maxVariable?: 'punct' | 'space';
+        backwards?: boolean;
+    };
+    hint?: Record<string, 1 | -1> | string;
+    maxTimeMS?: number;
+    readPreference?: string;
+    comment?: string;
+    tailable?: boolean;
+    awaitData?: boolean;
+    allowDiskUse?: boolean;
+}
+/**
+ * Model interface (placeholder - will be replaced by actual Model type)
+ */
+interface ModelLike$1<T = unknown> {
+    collection?: {
+        find(filter: FilterQuery<T>, options?: QueryOptions): Promise<T[]>;
+        findOne(filter: FilterQuery<T>, options?: QueryOptions): Promise<T | null>;
+        countDocuments(filter: FilterQuery<T>): Promise<number>;
+        estimatedDocumentCount(): Promise<number>;
+        distinct(field: string, filter?: FilterQuery<T>): Promise<unknown[]>;
+    };
+    modelName?: string;
+    schema?: {
+        getPreHooks(hook: string): Array<{
+            fn: Function;
+            options?: {
+                query?: boolean;
+            };
+        }>;
+        getPostHooks(hook: string): Array<{
+            fn: Function;
+            options?: {
+                query?: boolean;
+            };
+        }>;
+    };
+    hydrate?(doc: unknown): T;
+}
+/**
+ * Chainable query builder for Mondoo
+ *
+ * The Query class is LAZY - it doesn't execute until:
+ * - exec() is called
+ * - then() is called (await/Promise chain)
+ * - A terminal method is called
+ *
+ * @template TDoc - The document type
+ * @template TResult - The expected result type
+ */
+declare class Query<TDoc = unknown, TResult = TDoc> implements PromiseLike<TResult> {
+    /** The query filter object */
+    private _filter;
+    /** Fields to select/exclude (projection) */
+    private _projection;
+    /** Query options (sort, skip, limit, etc.) */
+    private _options;
+    /** Population options */
+    private _populate;
+    /** Whether to return plain objects */
+    private _lean;
+    /** Reference to the Model */
+    private _model;
+    /** The query operation type */
+    private _operation;
+    /** Current path for chained conditions (where().equals()) */
+    private _currentPath;
+    /** Update document for update operations */
+    private _update;
+    /** Distinct field for distinct queries */
+    private _distinctField;
+    /**
+     * Create a new Query instance
+     * @param model - The model to query against
+     * @param operation - The query operation type
+     * @param filter - Initial filter conditions
+     * @param update - Update document for update operations
+     */
+    constructor(model: ModelLike$1<TDoc>, operation?: QueryOperation, filter?: FilterQuery<TDoc>, update?: Record<string, unknown>);
+    /**
+     * Create a find query
+     */
+    static find<T>(model: ModelLike$1<T>, filter?: FilterQuery<T>): Query<T, T[]>;
+    /**
+     * Create a findOne query
+     */
+    static findOne<T>(model: ModelLike$1<T>, filter?: FilterQuery<T>): Query<T, T | null>;
+    /**
+     * Create a countDocuments query
+     */
+    static countDocuments<T>(model: ModelLike$1<T>, filter?: FilterQuery<T>): Query<T, number>;
+    /**
+     * Create an estimatedDocumentCount query
+     */
+    static estimatedDocumentCount<T>(model: ModelLike$1<T>): Query<T, number>;
+    /**
+     * Create a distinct query
+     */
+    static distinct<T>(model: ModelLike$1<T>, field: string, filter?: FilterQuery<T>): Query<T, unknown[]>;
+    /**
+     * Start building a condition on a path or add filter conditions
+     * @param path - The document path to query, or an object of conditions
+     * @param val - Optional direct value (Mongoose-style shorthand)
+     * @example query.where('age').gte(18)
+     * @example query.where({ name: 'John', age: 30 })
+     * @example query.where('name', 'John')
+     */
+    where(path: string, val?: unknown): this;
+    where(obj: Record<string, unknown>): this;
+    /**
+     * Add an equals condition
+     * @param val - The value to match
+     */
+    equals<V>(val: V): this;
+    /**
+     * Alias for equals
+     */
+    eq<V>(val: V): this;
+    /**
+     * Add a greater-than condition
+     * @param val - The minimum value (exclusive)
+     */
+    gt(val: number): this;
+    gt(path: string, val: number): this;
+    /**
+     * Add a greater-than-or-equal condition
+     * @param val - The minimum value (inclusive)
+     */
+    gte(val: number): this;
+    gte(path: string, val: number): this;
+    /**
+     * Add a less-than condition
+     * @param val - The maximum value (exclusive)
+     */
+    lt(val: number): this;
+    lt(path: string, val: number): this;
+    /**
+     * Add a less-than-or-equal condition
+     * @param val - The maximum value (inclusive)
+     */
+    lte(val: number): this;
+    lte(path: string, val: number): this;
+    /**
+     * Add a not-equal condition
+     * @param val - The value to not match
+     */
+    ne<V>(val: V): this;
+    ne<V>(path: string, val: V): this;
+    /**
+     * Add an $in condition (value must be in array)
+     * @param vals - Array of acceptable values
+     */
+    in<V>(vals: V[]): this;
+    in<V>(path: string, vals: V[]): this;
+    /**
+     * Add a $nin condition (value must not be in array)
+     * @param vals - Array of unacceptable values
+     */
+    nin<V>(vals: V[]): this;
+    nin<V>(path: string, vals: V[]): this;
+    /**
+     * Add an $exists condition
+     * @param exists - Whether the field must exist
+     */
+    exists(exists?: boolean): this;
+    exists(path: string, exists?: boolean): this;
+    /**
+     * Add a $regex condition
+     * @param pattern - The regex pattern to match
+     * @param flags - Optional regex flags
+     */
+    regex(pattern: RegExp | string, flags?: string): this;
+    regex(path: string, pattern: RegExp | string, flags?: string): this;
+    /**
+     * Add an $elemMatch condition for arrays
+     * @param criteria - The criteria for matching array elements
+     */
+    elemMatch(criteria: Record<string, unknown>): this;
+    elemMatch(path: string, criteria: Record<string, unknown>): this;
+    /**
+     * Add a $size condition for arrays
+     * @param n - The exact array size to match
+     */
+    size(n: number): this;
+    size(path: string, n: number): this;
+    /**
+     * Add an $all condition for arrays (must contain all values)
+     * @param arr - Array of values that must all be present
+     */
+    all<V>(arr: V[]): this;
+    all<V>(path: string, arr: V[]): this;
+    /**
+     * Add a $mod condition
+     * @param divisor - The divisor
+     * @param remainder - The expected remainder
+     */
+    mod(divisor: number, remainder: number): this;
+    mod(path: string, divisor: number, remainder: number): this;
+    /**
+     * Add conditions using $and
+     * @param conditions - Array of conditions to AND together
+     */
+    and(conditions: FilterQuery<TDoc>[]): this;
+    /**
+     * Add conditions using $or
+     * @param conditions - Array of conditions to OR together
+     */
+    or(conditions: FilterQuery<TDoc>[]): this;
+    /**
+     * Add conditions using $nor
+     * @param conditions - Array of conditions to NOR together
+     */
+    nor(conditions: FilterQuery<TDoc>[]): this;
+    /**
+     * Set fields to select (projection)
+     * @param fields - Fields to include/exclude
+     * @example query.select('name email') // include name and email
+     * @example query.select('-password') // exclude password
+     * @example query.select({ name: 1, email: 1 }) // include name and email
+     * @example query.select(['name', 'email']) // include name and email
+     */
+    select(fields: string | string[] | Record<string, 0 | 1>): this;
+    /**
+     * Alias for select
+     */
+    projection(fields: string | string[] | Record<string, 0 | 1>): this;
+    /**
+     * Set sort order
+     * @param order - Sort specification
+     * @example query.sort({ createdAt: -1 }) // descending
+     * @example query.sort('name -createdAt') // name asc, createdAt desc
+     * @example query.sort([['name', 1], ['createdAt', -1]])
+     */
+    sort(order: string | Record<string, 1 | -1 | 'asc' | 'desc'> | [string, 1 | -1 | 'asc' | 'desc'][]): this;
+    /**
+     * Set the maximum number of documents to return
+     * @param n - The maximum number of documents
+     */
+    limit(n: number): this;
+    /**
+     * Set the number of documents to skip
+     * @param n - The number of documents to skip
+     */
+    skip(n: number): this;
+    /**
+     * Enable lean mode - return plain JavaScript objects instead of Mondoo documents
+     * @param lean - Whether to enable lean mode (default: true)
+     */
+    lean<LeanResult = TResult>(lean?: boolean): Query<TDoc, LeanResult>;
+    /**
+     * Add population for referenced documents
+     * @param path - The path to populate, or population options
+     * @param select - Optional fields to select in populated documents
+     * @param options - Additional population options
+     */
+    populate(path: string | PopulateOptions$1 | PopulateOptions$1[], select?: string | string[] | Record<string, 0 | 1>, options?: Partial<PopulateOptions$1>): this;
+    /**
+     * Set the MongoDB session for transactions
+     * @param clientSession - The client session
+     */
+    session(clientSession: unknown): this;
+    /**
+     * Set batch size for cursor iteration
+     * @param size - The batch size
+     */
+    batchSize(size: number): this;
+    /**
+     * Set collation options
+     * @param collation - The collation options
+     */
+    collation(collation: QueryOptions['collation']): this;
+    /**
+     * Set index hint
+     * @param hint - The index hint
+     */
+    hint(hint: Record<string, 1 | -1> | string): this;
+    /**
+     * Set maximum execution time
+     * @param ms - Maximum time in milliseconds
+     */
+    maxTimeMS(ms: number): this;
+    /**
+     * Set read preference
+     * @param pref - The read preference
+     * @param tags - Optional read preference tags
+     */
+    read(pref: string, tags?: unknown[]): this;
+    /**
+     * Add a comment to the query
+     * @param comment - The comment string
+     */
+    comment(val: string): this;
+    /**
+     * Create a tailable cursor
+     * @param tailable - Whether the cursor is tailable
+     * @param awaitData - Whether to await data
+     */
+    tailable(tailable?: boolean, awaitData?: boolean): this;
+    /**
+     * Allow disk use for large sorts
+     * @param val - Whether to allow disk use
+     */
+    allowDiskUse(val?: boolean): this;
+    /**
+     * Set all query options at once
+     * @param options - The options object
+     */
+    setOptions(options: QueryOptions): this;
+    /**
+     * Set the update document
+     * @param update - The update document
+     */
+    setUpdate(update: Record<string, unknown>): this;
+    /**
+     * Merge another filter or query into this query
+     * @param source - The filter or query to merge
+     */
+    merge(source: Query<TDoc, unknown> | FilterQuery<TDoc>): this;
+    /**
+     * Set the entire filter
+     * @param filter - The new filter
+     */
+    setQuery(filter: FilterQuery<TDoc>): this;
+    /**
+     * Get the current filter
+     */
+    getFilter(): FilterQuery<TDoc>;
+    /**
+     * Alias for getFilter
+     */
+    getQuery(): FilterQuery<TDoc>;
+    /**
+     * Get the current options
+     */
+    getOptions(): QueryOptions;
+    /**
+     * Get the current projection
+     */
+    getProjection(): Record<string, 0 | 1> | null;
+    /**
+     * Get the population options
+     */
+    getPopulate(): PopulateOptions$1[];
+    /**
+     * Get the update document
+     */
+    getUpdate(): Record<string, unknown> | null;
+    /**
+     * Get the query operation type
+     */
+    op(): QueryOperation;
+    /**
+     * Get the model
+     */
+    model(): ModelLike$1<TDoc>;
+    /**
+     * Clone this query
+     */
+    clone(): Query<TDoc, TResult>;
+    /**
+     * Execute the query and return a Promise
+     */
+    exec(): Promise<TResult>;
+    /**
+     * Make the query thenable (allows await/Promise chain)
+     */
+    then<TFulfilled = TResult, TRejected = never>(onfulfilled?: ((value: TResult) => TFulfilled | PromiseLike<TFulfilled>) | null, onrejected?: ((reason: unknown) => TRejected | PromiseLike<TRejected>) | null): Promise<TFulfilled | TRejected>;
+    /**
+     * Handle rejection
+     */
+    catch<TRejected = never>(onrejected?: ((reason: unknown) => TRejected | PromiseLike<TRejected>) | null): Promise<TResult | TRejected>;
+    /**
+     * Finally handler
+     */
+    finally(onfinally?: (() => void) | null): Promise<TResult>;
+    /**
+     * Return a cursor for iteration (placeholder)
+     * This returns an async iterable that can be used with for-await-of
+     */
+    cursor(): QueryCursor<TDoc>;
+    /**
+     * Count documents matching the query
+     */
+    countDocuments(): Query<TDoc, number>;
+    /**
+     * Explain the query execution plan
+     */
+    explain(verbosity?: 'queryPlanner' | 'executionStats' | 'allPlansExecution'): Promise<unknown>;
+    /**
+     * Convert query to string representation
+     */
+    toString(): string;
+    /**
+     * Set a condition on the current path
+     */
+    private _setPathCondition;
+    /**
+     * Parse a projection string into an object
+     */
+    private _parseProjectionString;
+    /**
+     * Parse a sort string into an object
+     */
+    private _parseSortString;
+    /**
+     * Normalize sort order to 1 or -1
+     */
+    private _normalizeSortOrder;
+    /**
+     * Build final options object for the driver
+     */
+    private _buildOptions;
+    /**
+     * Get the hook name for the current operation
+     */
+    private _getHookName;
+    /**
+     * Get placeholder result for when no collection is available
+     */
+    private _getPlaceholderResult;
+    /**
+     * Apply population to results (placeholder)
+     */
+    private _applyPopulate;
+}
+/**
+ * Cursor for iterating over query results
+ * Provides async iteration support for streaming large result sets
+ */
+declare class QueryCursor<TDoc> implements AsyncIterable<TDoc> {
+    private _query;
+    private _results;
+    private _index;
+    private _closed;
+    constructor(query: Query<TDoc, TDoc[]>);
+    /**
+     * Close the cursor
+     */
+    close(): Promise<void>;
+    /**
+     * Check if the cursor is closed
+     */
+    get closed(): boolean;
+    /**
+     * Check if there are more documents
+     */
+    hasNext(): Promise<boolean>;
+    /**
+     * Get the next document
+     */
+    next(): Promise<TDoc | null>;
+    /**
+     * Execute a function for each document
+     * @param fn - The function to execute for each document
+     * @param options - Options for parallel processing
+     */
+    eachAsync(fn: (doc: TDoc, index: number) => void | Promise<void>, options?: {
+        parallel?: number;
+    }): Promise<void>;
+    /**
+     * Map documents to a new array
+     * @param fn - The mapping function
+     */
+    map<T>(fn: (doc: TDoc) => T | Promise<T>): Promise<T[]>;
+    /**
+     * Convert cursor to array
+     */
+    toArray(): Promise<TDoc[]>;
+    /**
+     * Rewind the cursor to the beginning
+     */
+    rewind(): this;
+    /**
+     * Add a cursor flag (placeholder for MongoDB cursor flags)
+     * @param flag - The flag name
+     * @param value - The flag value
+     */
+    addCursorFlag(flag: string, value: boolean): this;
+    /**
+     * Make the cursor async iterable
+     */
+    [Symbol.asyncIterator](): AsyncIterator<TDoc>;
+}
+
+/**
+ * Aggregate Builder - MongoDB Aggregation Pipeline for Mondoo
+ *
+ * @example
+ * ```typescript
+ * // Basic aggregation
+ * const results = await User.aggregate()
+ *   .match({ active: true })
+ *   .group({ _id: '$department', count: { $sum: 1 } })
+ *   .sort({ count: -1 })
+ *   .limit(10)
+ *   .exec()
+ *
+ * // With initial pipeline
+ * const stats = await Order.aggregate([
+ *   { $match: { status: 'completed' } }
+ * ])
+ *   .group({ _id: '$customerId', total: { $sum: '$amount' } })
+ *   .sort({ total: -1 })
+ *
+ * // Faceted search
+ * const results = await Product.aggregate()
+ *   .facet({
+ *     categories: [{ $group: { _id: '$category', count: { $sum: 1 } } }],
+ *     priceRanges: [{ $bucket: { groupBy: '$price', boundaries: [0, 100, 500, 1000] } }]
+ *   })
+ * ```
+ */
+
+/**
+ * Options for aggregate execution
+ */
+interface AggregateOptions {
+    /** Allow disk use for large result sets */
+    allowDiskUse?: boolean;
+    /** Set batch size for cursor */
+    batchSize?: number;
+    /** Maximum time for operation (ms) */
+    maxTimeMS?: number;
+    /** Read preference */
+    readPreference?: string;
+    /** Read concern level */
+    readConcern?: {
+        level: string;
+    };
+    /** Collation options */
+    collation?: {
+        locale: string;
+        caseLevel?: boolean;
+        caseFirst?: 'upper' | 'lower' | 'off';
+        strength?: 1 | 2 | 3 | 4 | 5;
+        numericOrdering?: boolean;
+        alternate?: 'non-ignorable' | 'shifted';
+        maxVariable?: 'punct' | 'space';
+        backwards?: boolean;
+    };
+    /** Comment for logging */
+    comment?: string;
+    /** Hint for index usage */
+    hint?: Record<string, 1 | -1> | string;
+    /** Let variables for the pipeline */
+    let?: Record<string, unknown>;
+    /** Client session for transactions */
+    session?: unknown;
+    /** Write concern (for $out and $merge stages) */
+    writeConcern?: {
+        w?: number | 'majority';
+        j?: boolean;
+        wtimeout?: number;
+    };
+    /** Bypass document validation (for $out and $merge) */
+    bypassDocumentValidation?: boolean;
+}
+/**
+ * $lookup stage options
+ */
+interface LookupOptions {
+    from: string;
+    localField?: string;
+    foreignField?: string;
+    as: string;
+    let?: Record<string, unknown>;
+    pipeline?: Record<string, unknown>[];
+}
+/**
+ * $unwind stage options
+ */
+interface UnwindOptions {
+    path: string;
+    includeArrayIndex?: string;
+    preserveNullAndEmptyArrays?: boolean;
+}
+/**
+ * $bucket stage options
+ */
+interface BucketOptions {
+    groupBy: string | Record<string, unknown>;
+    boundaries: (number | Date)[];
+    default?: unknown;
+    output?: Record<string, unknown>;
+}
+/**
+ * $bucketAuto stage options
+ */
+interface BucketAutoOptions {
+    groupBy: string | Record<string, unknown>;
+    buckets: number;
+    output?: Record<string, unknown>;
+    granularity?: 'R5' | 'R10' | 'R20' | 'R40' | 'R80' | '1-2-5' | 'E6' | 'E12' | 'E24' | 'E48' | 'E96' | 'E192' | 'POWERSOF2';
+}
+/**
+ * $merge stage options
+ */
+interface MergeOptions {
+    into: string | {
+        db: string;
+        coll: string;
+    };
+    on?: string | string[];
+    whenMatched?: 'replace' | 'keepExisting' | 'merge' | 'fail' | Record<string, unknown>[];
+    whenNotMatched?: 'insert' | 'discard' | 'fail';
+    let?: Record<string, unknown>;
+}
+/**
+ * $graphLookup stage options
+ */
+interface GraphLookupOptions {
+    from: string;
+    startWith: string | Record<string, unknown>;
+    connectFromField: string;
+    connectToField: string;
+    as: string;
+    maxDepth?: number;
+    depthField?: string;
+    restrictSearchWithMatch?: Record<string, unknown>;
+}
+/**
+ * $geoNear stage options
+ */
+interface GeoNearOptions {
+    near: {
+        type: 'Point';
+        coordinates: [number, number];
+    } | [number, number];
+    distanceField: string;
+    spherical?: boolean;
+    maxDistance?: number;
+    minDistance?: number;
+    query?: Record<string, unknown>;
+    distanceMultiplier?: number;
+    includeLocs?: string;
+    key?: string;
+}
+/**
+ * $sample stage options
+ */
+interface SampleOptions {
+    size: number;
+}
+/**
+ * $unionWith stage options
+ */
+interface UnionWithOptions {
+    coll: string;
+    pipeline?: Record<string, unknown>[];
+}
+/**
+ * Model interface for aggregate operations
+ */
+interface AggregateModelLike<T = unknown> {
+    collection?: {
+        aggregate(pipeline: Record<string, unknown>[], options?: AggregateOptions): Promise<T[]>;
+    };
+    modelName?: string;
+    schema?: Schema<any>;
+}
+/**
+ * Chainable aggregation pipeline builder for Mondoo
+ *
+ * The Aggregate class is LAZY - it doesn't execute until:
+ * - exec() is called
+ * - then() is called (await/Promise chain)
+ *
+ * @template TResult - The expected result type
+ */
+declare class Aggregate<TResult = unknown> implements PromiseLike<TResult[]> {
+    /** The aggregation pipeline stages */
+    private _pipeline;
+    /** Aggregation options */
+    private _options;
+    /** Reference to the Model */
+    private _model;
+    /**
+     * Create a new Aggregate instance
+     * @param model - The model to aggregate against
+     * @param pipeline - Initial pipeline stages
+     */
+    constructor(model: AggregateModelLike, pipeline?: Record<string, unknown>[]);
+    /**
+     * Add a $match stage to filter documents
+     * @param filter - The filter conditions
+     * @example aggregate.match({ status: 'active', age: { $gte: 18 } })
+     */
+    match(filter: Record<string, unknown>): this;
+    /**
+     * Add a $project stage to reshape documents
+     * @param spec - The projection specification
+     * @example aggregate.project({ name: 1, fullName: { $concat: ['$firstName', ' ', '$lastName'] } })
+     */
+    project(spec: Record<string, unknown>): this;
+    /**
+     * Add a $group stage to group documents
+     * @param spec - The grouping specification (must include _id)
+     * @example aggregate.group({ _id: '$department', count: { $sum: 1 }, avgSalary: { $avg: '$salary' } })
+     */
+    group(spec: Record<string, unknown>): this;
+    /**
+     * Add a $sort stage to order documents
+     * @param spec - The sort specification
+     * @example aggregate.sort({ count: -1, name: 1 })
+     */
+    sort(spec: Record<string, 1 | -1 | {
+        $meta: string;
+    }>): this;
+    /**
+     * Add a $limit stage to limit number of documents
+     * @param n - Maximum number of documents
+     * @example aggregate.limit(10)
+     */
+    limit(n: number): this;
+    /**
+     * Add a $skip stage to skip documents
+     * @param n - Number of documents to skip
+     * @example aggregate.skip(20)
+     */
+    skip(n: number): this;
+    /**
+     * Add a $unwind stage to deconstruct arrays
+     * @param path - The array field path or unwind options
+     * @example aggregate.unwind('$tags')
+     * @example aggregate.unwind({ path: '$tags', preserveNullAndEmptyArrays: true })
+     */
+    unwind(path: string | UnwindOptions): this;
+    /**
+     * Add a $lookup stage to join with another collection
+     * @param spec - The lookup specification
+     * @example aggregate.lookup({ from: 'orders', localField: '_id', foreignField: 'customerId', as: 'orders' })
+     */
+    lookup(spec: LookupOptions): this;
+    /**
+     * Add a $facet stage for multi-faceted aggregations
+     * @param spec - The facet specifications
+     * @example aggregate.facet({ byCategory: [{ $group: { _id: '$category' } }], byPrice: [{ $bucket: {...} }] })
+     */
+    facet(spec: Record<string, Record<string, unknown>[]>): this;
+    /**
+     * Add a $bucket stage to categorize documents into groups
+     * @param spec - The bucket specification
+     * @example aggregate.bucket({ groupBy: '$price', boundaries: [0, 100, 500, 1000], default: 'Other' })
+     */
+    bucket(spec: BucketOptions): this;
+    /**
+     * Add a $bucketAuto stage for automatic bucket boundaries
+     * @param spec - The bucket auto specification
+     * @example aggregate.bucketAuto({ groupBy: '$price', buckets: 4 })
+     */
+    bucketAuto(spec: BucketAutoOptions): this;
+    /**
+     * Add a $addFields stage to add new fields
+     * @param fields - The fields to add
+     * @example aggregate.addFields({ fullName: { $concat: ['$firstName', ' ', '$lastName'] } })
+     */
+    addFields(fields: Record<string, unknown>): this;
+    /**
+     * Add a $set stage (alias for $addFields)
+     * @param fields - The fields to set
+     */
+    set(fields: Record<string, unknown>): this;
+    /**
+     * Add a $replaceRoot stage to replace the document root
+     * @param spec - The replacement specification
+     * @example aggregate.replaceRoot({ newRoot: '$embeddedDoc' })
+     */
+    replaceRoot(spec: {
+        newRoot: string | Record<string, unknown>;
+    }): this;
+    /**
+     * Add a $replaceWith stage (alias for $replaceRoot)
+     * @param replacement - The replacement expression
+     */
+    replaceWith(replacement: string | Record<string, unknown>): this;
+    /**
+     * Add a $count stage to count documents
+     * @param field - The name of the count field
+     * @example aggregate.count('total')
+     */
+    count(field: string): this;
+    /**
+     * Add a $merge stage to write results to a collection
+     * @param spec - The merge specification (string for collection name or options object)
+     * @example aggregate.merge('output_collection')
+     * @example aggregate.merge({ into: 'output', whenMatched: 'replace' })
+     */
+    merge(spec: string | MergeOptions): this;
+    /**
+     * Add a $out stage to write results to a collection
+     * @param collection - The output collection name
+     * @example aggregate.out('archived_orders')
+     */
+    out(collection: string): this;
+    /**
+     * Add a $redact stage for field-level access control
+     * @param expression - The redact expression
+     * @example aggregate.redact({ $cond: { if: { $eq: ['$level', 'public'] }, then: '$$DESCEND', else: '$$PRUNE' } })
+     */
+    redact(expression: Record<string, unknown>): this;
+    /**
+     * Add a $sample stage to randomly select documents
+     * @param spec - The sample specification or size number
+     * @example aggregate.sample(100)
+     * @example aggregate.sample({ size: 100 })
+     */
+    sample(spec: number | SampleOptions): this;
+    /**
+     * Add a $sortByCount stage (groups and counts, then sorts)
+     * @param expression - The field or expression to sort by count
+     * @example aggregate.sortByCount('$category')
+     */
+    sortByCount(expression: string | Record<string, unknown>): this;
+    /**
+     * Add a $graphLookup stage for recursive lookups
+     * @param spec - The graph lookup specification
+     */
+    graphLookup(spec: GraphLookupOptions): this;
+    /**
+     * Add a $geoNear stage for geospatial queries (must be first stage)
+     * @param spec - The geo near specification
+     */
+    near(spec: GeoNearOptions): this;
+    /**
+     * Add a $unset stage to remove fields
+     * @param fields - Field(s) to remove
+     * @example aggregate.unset('password')
+     * @example aggregate.unset(['password', 'internalNotes'])
+     */
+    unset(fields: string | string[]): this;
+    /**
+     * Add a $densify stage to fill in gaps
+     * @param spec - The densify specification
+     */
+    densify(spec: {
+        field: string;
+        partitionByFields?: string[];
+        range: {
+            step: number;
+            unit?: string;
+            bounds: [unknown, unknown] | 'full' | 'partition';
+        };
+    }): this;
+    /**
+     * Add a $fill stage to fill null/missing values
+     * @param spec - The fill specification
+     */
+    fill(spec: {
+        partitionBy?: Record<string, unknown>;
+        partitionByFields?: string[];
+        sortBy?: Record<string, 1 | -1>;
+        output: Record<string, {
+            value: unknown;
+        } | {
+            method: 'linear' | 'locf';
+        }>;
+    }): this;
+    /**
+     * Add a $unionWith stage to combine pipelines
+     * @param spec - The union specification
+     * @example aggregate.unionWith({ coll: 'archive', pipeline: [{ $match: { archived: true } }] })
+     */
+    unionWith(spec: string | UnionWithOptions): this;
+    /**
+     * Add a $setWindowFields stage for window functions
+     * @param spec - The window fields specification
+     */
+    setWindowFields(spec: {
+        partitionBy?: string | Record<string, unknown>;
+        sortBy?: Record<string, 1 | -1>;
+        output: Record<string, unknown>;
+    }): this;
+    /**
+     * Add a $search stage (MongoDB Atlas Search)
+     * @param spec - The search specification
+     */
+    search(spec: Record<string, unknown>): this;
+    /**
+     * Add a $searchMeta stage (MongoDB Atlas Search metadata)
+     * @param spec - The search meta specification
+     */
+    searchMeta(spec: Record<string, unknown>): this;
+    /**
+     * Append one or more stages to the pipeline
+     * @param stages - The stages to append
+     * @example aggregate.append({ $match: { active: true } }, { $sort: { name: 1 } })
+     */
+    append(...stages: Record<string, unknown>[]): this;
+    /**
+     * Add a raw stage to the pipeline
+     * @param stage - The raw stage object
+     */
+    addStage(stage: Record<string, unknown>): this;
+    /**
+     * Set an option for the aggregation
+     * @param key - The option name
+     * @param value - The option value
+     */
+    option<K extends keyof AggregateOptions>(key: K, value: AggregateOptions[K]): this;
+    /**
+     * Set multiple options at once
+     * @param options - The options object
+     */
+    setOptions(options: AggregateOptions): this;
+    /**
+     * Enable disk use for large result sets
+     * @param val - Whether to allow disk use
+     */
+    allowDiskUse(val?: boolean): this;
+    /**
+     * Set batch size for cursor
+     * @param size - The batch size
+     */
+    batchSize(size: number): this;
+    /**
+     * Set read preference
+     * @param pref - The read preference
+     */
+    read(pref: string): this;
+    /**
+     * Set read concern
+     * @param level - The read concern level
+     */
+    readConcern(level: string): this;
+    /**
+     * Set maximum time for operation
+     * @param ms - Maximum time in milliseconds
+     */
+    maxTimeMS(ms: number): this;
+    /**
+     * Set collation options
+     * @param collation - The collation options
+     */
+    collation(collation: AggregateOptions['collation']): this;
+    /**
+     * Add a comment to the aggregation
+     * @param val - The comment string
+     */
+    comment(val: string): this;
+    /**
+     * Set index hint
+     * @param hint - The index hint
+     */
+    hint(hint: Record<string, 1 | -1> | string): this;
+    /**
+     * Set let variables for the pipeline
+     * @param variables - The variable definitions
+     */
+    let(variables: Record<string, unknown>): this;
+    /**
+     * Set session for transactions
+     * @param clientSession - The client session
+     */
+    session(clientSession: unknown): this;
+    /**
+     * Get the current pipeline
+     */
+    pipeline(): Record<string, unknown>[];
+    /**
+     * Get the current options
+     */
+    getOptions(): AggregateOptions;
+    /**
+     * Get the model reference
+     */
+    model(): AggregateModelLike;
+    /**
+     * Clone this aggregate
+     */
+    clone(): Aggregate<TResult>;
+    /**
+     * Execute the aggregation and return a Promise
+     */
+    exec(): Promise<TResult[]>;
+    /**
+     * Make the aggregate thenable (allows await/Promise chain)
+     */
+    then<TFulfilled = TResult[], TRejected = never>(onfulfilled?: ((value: TResult[]) => TFulfilled | PromiseLike<TFulfilled>) | null, onrejected?: ((reason: unknown) => TRejected | PromiseLike<TRejected>) | null): Promise<TFulfilled | TRejected>;
+    /**
+     * Handle rejection
+     */
+    catch<TRejected = never>(onrejected?: ((reason: unknown) => TRejected | PromiseLike<TRejected>) | null): Promise<TResult[] | TRejected>;
+    /**
+     * Finally handler
+     */
+    finally(onfinally?: (() => void) | null): Promise<TResult[]>;
+    /**
+     * Return a cursor for iteration
+     * This returns an async iterable that can be used with for-await-of
+     */
+    cursor(): AggregateCursor<TResult>;
+    /**
+     * Explain the aggregation execution plan
+     */
+    explain(verbosity?: 'queryPlanner' | 'executionStats' | 'allPlansExecution'): Promise<unknown>;
+    /**
+     * Convert aggregation to string representation
+     */
+    toString(): string;
+    /**
+     * Symbol.toStringTag for better debugging
+     */
+    get [Symbol.toStringTag](): string;
+}
+/**
+ * Cursor for iterating over aggregation results
+ * Provides async iteration support for streaming large result sets
+ */
+declare class AggregateCursor<TResult> implements AsyncIterable<TResult> {
+    private _aggregate;
+    private _results;
+    private _index;
+    private _closed;
+    constructor(aggregate: Aggregate<TResult>);
+    /**
+     * Close the cursor
+     */
+    close(): Promise<void>;
+    /**
+     * Check if the cursor is closed
+     */
+    get closed(): boolean;
+    /**
+     * Check if there are more documents
+     */
+    hasNext(): Promise<boolean>;
+    /**
+     * Get the next document
+     */
+    next(): Promise<TResult | null>;
+    /**
+     * Execute a function for each document
+     * @param fn - The function to execute for each document
+     * @param options - Options for parallel processing
+     */
+    eachAsync(fn: (doc: TResult, index: number) => void | Promise<void>, options?: {
+        parallel?: number;
+    }): Promise<void>;
+    /**
+     * Map documents to a new array
+     * @param fn - The mapping function
+     */
+    map<T>(fn: (doc: TResult) => T | Promise<T>): Promise<T[]>;
+    /**
+     * Convert cursor to array
+     */
+    toArray(): Promise<TResult[]>;
+    /**
+     * Rewind the cursor to the beginning
+     */
+    rewind(): this;
+    /**
+     * Add a cursor flag (placeholder for MongoDB cursor flags)
+     * @param flag - The flag name
+     * @param value - The flag value
+     */
+    addCursorFlag(flag: string, value: boolean): this;
+    /**
+     * Make the cursor async iterable
+     */
+    [Symbol.asyncIterator](): AsyncIterator<TResult>;
+}
+
+/**
+ * Model class - wraps MongoDB collection operations and provides Mongoose-compatible API
+ */
+
+interface ModelOptions {
+    collection?: string;
+    connection?: any;
+    skipInit?: boolean;
+}
+interface InsertManyOptions {
+    ordered?: boolean;
+    rawResult?: boolean;
+    session?: any;
+    lean?: boolean;
+}
+interface UpdateResult {
+    acknowledged: boolean;
+    modifiedCount: number;
+    upsertedId?: ObjectId;
+    upsertedCount: number;
+    matchedCount: number;
+}
+interface DeleteResult {
+    acknowledged: boolean;
+    deletedCount: number;
+}
+interface IndexDefinition {
+    fields: Record<string, 1 | -1 | 'text' | '2dsphere'>;
+    options?: {
+        unique?: boolean;
+        sparse?: boolean;
+        background?: boolean;
+        expireAfterSeconds?: number;
+        name?: string;
+        partialFilterExpression?: Record<string, any>;
+    };
+}
+/**
+ * Interface for Model constructor (callable as new Model())
+ */
+interface ModelConstructor<T extends Record<string, unknown> = Record<string, unknown>> {
+    new (doc?: Partial<T>): Document<T> & T;
+    schema: Schema<T>;
+    collection: any;
+    modelName: string;
+    db: any;
+    baseModelName?: string;
+    discriminators?: Map<string, ModelConstructor<any>>;
+    create(doc: Partial<T>): Promise<Document<T> & T>;
+    create(docs: Partial<T>[]): Promise<(Document<T> & T)[]>;
+    insertMany(docs: Partial<T>[], options?: InsertManyOptions): Promise<(Document<T> & T)[]>;
+    find(filter?: Record<string, any>, projection?: Record<string, 0 | 1> | string, options?: QueryOptions): Query<T, (Document<T> & T)[]>;
+    findOne(filter?: Record<string, any>, projection?: Record<string, 0 | 1> | string, options?: QueryOptions): Query<T, (Document<T> & T) | null>;
+    findById(id: ObjectId | string, projection?: Record<string, 0 | 1> | string, options?: QueryOptions): Query<T, (Document<T> & T) | null>;
+    findByIdAndUpdate(id: ObjectId | string, update: Record<string, any>, options?: QueryOptions & {
+        new?: boolean;
+    }): Query<T, (Document<T> & T) | null>;
+    findByIdAndDelete(id: ObjectId | string, options?: QueryOptions): Query<T, (Document<T> & T) | null>;
+    findOneAndUpdate(filter: Record<string, any>, update: Record<string, any>, options?: QueryOptions & {
+        new?: boolean;
+        upsert?: boolean;
+    }): Query<T, (Document<T> & T) | null>;
+    findOneAndDelete(filter: Record<string, any>, options?: QueryOptions): Query<T, (Document<T> & T) | null>;
+    findOneAndReplace(filter: Record<string, any>, replacement: Partial<T>, options?: QueryOptions & {
+        new?: boolean;
+        upsert?: boolean;
+    }): Query<T, (Document<T> & T) | null>;
+    updateOne(filter: Record<string, any>, update: Record<string, any>, options?: QueryOptions & {
+        upsert?: boolean;
+    }): Query<T, UpdateResult>;
+    updateMany(filter: Record<string, any>, update: Record<string, any>, options?: QueryOptions & {
+        upsert?: boolean;
+    }): Query<T, UpdateResult>;
+    replaceOne(filter: Record<string, any>, replacement: Partial<T>, options?: QueryOptions & {
+        upsert?: boolean;
+    }): Query<T, UpdateResult>;
+    deleteOne(filter: Record<string, any>, options?: QueryOptions): Query<T, DeleteResult>;
+    deleteMany(filter: Record<string, any>, options?: QueryOptions): Query<T, DeleteResult>;
+    countDocuments(filter?: Record<string, any>): Query<T, number>;
+    estimatedDocumentCount(): Promise<number>;
+    distinct(field: string, filter?: Record<string, any>): Query<T, any[]>;
+    hydrate(doc: Record<string, any>): Document<T> & T;
+    createIndexes(): Promise<void>;
+    ensureIndexes(): Promise<void>;
+    syncIndexes(): Promise<string[]>;
+    listIndexes(): Promise<IndexDefinition[]>;
+    exists(filter: Record<string, any>): Promise<{
+        _id: ObjectId;
+    } | null>;
+    where(path: string, val?: any): Query<T, (Document<T> & T)[]>;
+    aggregate<R = any>(pipeline?: Record<string, any>[]): Aggregate<R>;
+    bulkWrite(ops: BulkWriteOperation<T>[], options?: {
+        ordered?: boolean;
+        session?: any;
+    }): Promise<BulkWriteResult>;
+    watch(pipeline?: Record<string, any>[], options?: Record<string, any>): ChangeStream<T>;
+    _saveDocument(doc: Document<T>, options?: any): Promise<Document<T>>;
+    _deleteDocument(doc: Document<T>, options?: any): Promise<Document<T>>;
+    _populateDocument(doc: Document<T>, path: string | string[] | Record<string, any>): Promise<Document<T>>;
+}
+interface BulkWriteOperation<T extends Record<string, unknown> = Record<string, unknown>> {
+    insertOne?: {
+        document: Partial<T>;
+    };
+    updateOne?: {
+        filter: Record<string, any>;
+        update: Record<string, any>;
+        upsert?: boolean;
+    };
+    updateMany?: {
+        filter: Record<string, any>;
+        update: Record<string, any>;
+        upsert?: boolean;
+    };
+    deleteOne?: {
+        filter: Record<string, any>;
+    };
+    deleteMany?: {
+        filter: Record<string, any>;
+    };
+    replaceOne?: {
+        filter: Record<string, any>;
+        replacement: Partial<T>;
+        upsert?: boolean;
+    };
+}
+interface BulkWriteResult {
+    insertedCount: number;
+    matchedCount: number;
+    modifiedCount: number;
+    deletedCount: number;
+    upsertedCount: number;
+    upsertedIds: Record<number, ObjectId>;
+}
+interface ChangeStream<T extends Record<string, unknown> = Record<string, unknown>> {
+    on(event: 'change', listener: (change: ChangeEvent<T>) => void): this;
+    on(event: 'error', listener: (error: Error) => void): this;
+    on(event: 'close', listener: () => void): this;
+    close(): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterator<ChangeEvent<T>>;
+}
+interface ChangeEvent<T extends Record<string, unknown> = Record<string, unknown>> {
+    operationType: 'insert' | 'update' | 'replace' | 'delete' | 'invalidate' | 'drop' | 'dropDatabase' | 'rename';
+    fullDocument?: T;
+    documentKey?: {
+        _id: ObjectId;
+    };
+    updateDescription?: {
+        updatedFields: Record<string, any>;
+        removedFields: string[];
+    };
+}
+/**
+ * Base Model class with static methods
+ */
+declare class Model<T extends Record<string, unknown> = Record<string, unknown>> {
+    /** The schema for this model */
+    static schema: Schema<any>;
+    /** MongoDB collection reference (placeholder) */
+    static collection: any;
+    /** The model name */
+    static modelName: string;
+    /** Database connection reference (placeholder) */
+    static db: any;
+    /** Base path for discriminators */
+    static baseModelName?: string;
+    /** Discriminator mapping */
+    static discriminators?: Map<string, ModelConstructor<any>>;
+    /**
+     * Create one or more documents
+     */
+    static create<T extends Record<string, unknown>>(this: ModelConstructor<T>, doc: Partial<T>): Promise<Document<T> & T>;
+    static create<T extends Record<string, unknown>>(this: ModelConstructor<T>, docs: Partial<T>[]): Promise<(Document<T> & T)[]>;
+    /**
+     * Insert multiple documents
+     */
+    static insertMany<T extends Record<string, unknown>>(this: ModelConstructor<T>, docs: Partial<T>[], options?: InsertManyOptions): Promise<(Document<T> & T)[]>;
+    /**
+     * Find documents matching filter
+     */
+    static find<T extends Record<string, unknown>>(this: ModelConstructor<T>, filter?: Record<string, any>, projection?: Record<string, 0 | 1> | string, options?: QueryOptions): Query<T, (Document<T> & T)[]>;
+    /**
+     * Find a single document
+     */
+    static findOne<T extends Record<string, unknown>>(this: ModelConstructor<T>, filter?: Record<string, any>, projection?: Record<string, 0 | 1> | string, options?: QueryOptions): Query<T, (Document<T> & T) | null>;
+    /**
+     * Find a document by its _id
+     */
+    static findById<T extends Record<string, unknown>>(this: ModelConstructor<T>, id: ObjectId | string, projection?: Record<string, 0 | 1> | string, options?: QueryOptions): Query<T, (Document<T> & T) | null>;
+    /**
+     * Find a document by _id and update it
+     */
+    static findByIdAndUpdate<T extends Record<string, unknown>>(this: ModelConstructor<T>, id: ObjectId | string, update: Record<string, any>, options?: QueryOptions & {
+        new?: boolean;
+    }): Query<T, (Document<T> & T) | null>;
+    /**
+     * Find a document by _id and delete it
+     */
+    static findByIdAndDelete<T extends Record<string, unknown>>(this: ModelConstructor<T>, id: ObjectId | string, options?: QueryOptions): Query<T, (Document<T> & T) | null>;
+    /**
+     * Find a document and update it
+     */
+    static findOneAndUpdate<T extends Record<string, unknown>>(this: ModelConstructor<T>, filter: Record<string, any>, update: Record<string, any>, options?: QueryOptions & {
+        new?: boolean;
+        upsert?: boolean;
+    }): Query<T, (Document<T> & T) | null>;
+    /**
+     * Find a document and delete it
+     */
+    static findOneAndDelete<T extends Record<string, unknown>>(this: ModelConstructor<T>, filter: Record<string, any>, options?: QueryOptions): Query<T, (Document<T> & T) | null>;
+    /**
+     * Find a document and replace it
+     */
+    static findOneAndReplace<T extends Record<string, unknown>>(this: ModelConstructor<T>, filter: Record<string, any>, replacement: Partial<T>, options?: QueryOptions & {
+        new?: boolean;
+        upsert?: boolean;
+    }): Query<T, (Document<T> & T) | null>;
+    /**
+     * Update a single document
+     */
+    static updateOne<T extends Record<string, unknown>>(this: ModelConstructor<T>, filter: Record<string, any>, update: Record<string, any>, options?: QueryOptions & {
+        upsert?: boolean;
+    }): Query<T, UpdateResult>;
+    /**
+     * Update multiple documents
+     */
+    static updateMany<T extends Record<string, unknown>>(this: ModelConstructor<T>, filter: Record<string, any>, update: Record<string, any>, options?: QueryOptions & {
+        upsert?: boolean;
+    }): Query<T, UpdateResult>;
+    /**
+     * Replace a single document
+     */
+    static replaceOne<T extends Record<string, unknown>>(this: ModelConstructor<T>, filter: Record<string, any>, replacement: Partial<T>, options?: QueryOptions & {
+        upsert?: boolean;
+    }): Query<T, UpdateResult>;
+    /**
+     * Delete a single document
+     */
+    static deleteOne<T extends Record<string, unknown>>(this: ModelConstructor<T>, filter: Record<string, any>, options?: QueryOptions): Query<T, DeleteResult>;
+    /**
+     * Delete multiple documents
+     */
+    static deleteMany<T extends Record<string, unknown>>(this: ModelConstructor<T>, filter: Record<string, any>, options?: QueryOptions): Query<T, DeleteResult>;
+    /**
+     * Count documents matching filter
+     */
+    static countDocuments<T extends Record<string, unknown>>(this: ModelConstructor<T>, filter?: Record<string, any>): Query<T, number>;
+    /**
+     * Estimated document count (faster, uses collection metadata)
+     */
+    static estimatedDocumentCount<T extends Record<string, unknown>>(this: ModelConstructor<T>): Promise<number>;
+    /**
+     * Get distinct values for a field
+     */
+    static distinct<T extends Record<string, unknown>>(this: ModelConstructor<T>, field: string, filter?: Record<string, any>): Query<T, any[]>;
+    /**
+     * Check if any document exists matching filter
+     */
+    static exists<T extends Record<string, unknown>>(this: ModelConstructor<T>, filter: Record<string, any>): Promise<{
+        _id: ObjectId;
+    } | null>;
+    /**
+     * Create a Document instance from a plain object (without saving)
+     */
+    static hydrate<T extends Record<string, unknown>>(this: ModelConstructor<T>, doc: Partial<T>): Document<T> & T;
+    /**
+     * Start a query with where clause
+     */
+    static where<T extends Record<string, unknown>>(this: ModelConstructor<T>, path: string, val?: any): Query<T, (Document<T> & T)[]>;
+    /**
+     * Start an aggregation pipeline
+     */
+    static aggregate<T extends Record<string, unknown>, R = any>(this: ModelConstructor<T>, pipeline?: Record<string, any>[]): Aggregate<R>;
+    /**
+     * Create indexes defined in the schema
+     */
+    static createIndexes<T extends Record<string, unknown>>(this: ModelConstructor<T>): Promise<void>;
+    /**
+     * Ensure indexes exist (alias for createIndexes)
+     */
+    static ensureIndexes<T extends Record<string, unknown>>(this: ModelConstructor<T>): Promise<void>;
+    /**
+     * Sync indexes - create missing and drop extra indexes
+     */
+    static syncIndexes<T extends Record<string, unknown>>(this: ModelConstructor<T>): Promise<string[]>;
+    /**
+     * List all indexes
+     */
+    static listIndexes<T extends Record<string, unknown>>(this: ModelConstructor<T>): Promise<IndexDefinition[]>;
+    /**
+     * Execute bulk write operations
+     */
+    static bulkWrite<T extends Record<string, unknown>>(this: ModelConstructor<T>, ops: BulkWriteOperation<T>[], options?: {
+        ordered?: boolean;
+        session?: any;
+    }): Promise<BulkWriteResult>;
+    /**
+     * Watch for changes on the collection
+     */
+    static watch<T extends Record<string, unknown>>(this: ModelConstructor<T>, pipeline?: Record<string, any>[], options?: Record<string, any>): ChangeStream<T>;
+    /**
+     * Create a discriminator model
+     */
+    static discriminator<T extends Record<string, unknown>, D extends T>(this: ModelConstructor<T>, name: string, schema: Schema<D>, value?: string): ModelConstructor<D>;
+    /**
+     * Save a document to the database
+     * @internal
+     */
+    static _saveDocument<T extends Record<string, unknown>>(this: ModelConstructor<T>, doc: Document<T>, options?: any): Promise<Document<T>>;
+    /**
+     * Delete a document from the database
+     * @internal
+     */
+    static _deleteDocument<T extends Record<string, unknown>>(this: ModelConstructor<T>, doc: Document<T>, options?: any): Promise<Document<T>>;
+    /**
+     * Populate a document
+     * @internal
+     */
+    static _populateDocument<T extends Record<string, unknown>>(this: ModelConstructor<T>, doc: Document<T>, path: string | string[] | Record<string, any>): Promise<Document<T>>;
+    /**
+     * Translate aliases in an update document
+     */
+    static translateAliases<T extends Record<string, unknown>>(this: ModelConstructor<T>, raw: Record<string, any>): Record<string, any>;
+    /**
+     * Validate paths
+     */
+    static validate<T extends Record<string, unknown>>(this: ModelConstructor<T>, obj: Partial<T>, paths?: string[]): Promise<void>;
+    /**
+     * Cast a filter to proper types
+     */
+    static castObject<T extends Record<string, unknown>>(this: ModelConstructor<T>, obj: Record<string, any>): Record<string, any>;
+}
+/**
+ * Create a new model from a schema
+ */
+declare function model<T extends Record<string, unknown> = Record<string, unknown>>(name: string, schema: Schema<T>, options?: ModelOptions): ModelConstructor<T>;
+/**
+ * Get a registered model by name
+ */
+declare function getModel<T extends Record<string, unknown> = Record<string, unknown>>(name: string): ModelConstructor<T> | undefined;
+/**
+ * Check if a model is registered
+ */
+declare function hasModel(name: string): boolean;
+/**
+ * Delete a registered model
+ */
+declare function deleteModel(name: string): boolean;
+/**
+ * Get all registered model names
+ */
+declare function modelNames(): string[];
+
+/**
+ * Middleware/Hooks System for Mondoo
+ *
+ * Implements Mongoose-compatible pre/post hooks for documents, queries, models, and aggregations.
+ */
+
+/**
+ * Document middleware hooks - operate on document instances
+ */
+type DocumentHookType = 'validate' | 'save' | 'remove' | 'updateOne' | 'deleteOne' | 'init';
+/**
+ * Query middleware hooks - operate on Query objects
+ */
+type QueryHookType = 'find' | 'findOne' | 'findOneAndUpdate' | 'findOneAndDelete' | 'findOneAndReplace' | 'updateOne' | 'updateMany' | 'deleteOne' | 'deleteMany';
+/**
+ * Model middleware hooks - operate on Model class methods
+ */
+type ModelHookType = 'insertMany';
+/**
+ * Aggregate middleware hooks - operate on Aggregation pipeline
+ */
+type AggregateHookType = 'aggregate';
+interface MiddlewareOptions {
+    /** Run this hook on document operations (default: true for document hooks) */
+    document?: boolean;
+    /** Run this hook on query operations (default: true for query hooks) */
+    query?: boolean;
+}
+interface MiddlewareEntry {
+    fn: Function;
+    options?: MiddlewareOptions;
+}
+/**
+ * Context passed to hooks during execution
+ */
+interface HookContext {
+    /** The document being operated on (for document hooks) */
+    document?: any;
+    /** The query being executed (for query hooks) */
+    query?: any;
+    /** The model class */
+    model?: any;
+    /** The aggregation pipeline (for aggregate hooks) */
+    pipeline?: any[];
+    /** Operation-specific options */
+    options?: Record<string, any>;
+    /** Whether this is a new document (for save hooks) */
+    isNew?: boolean;
+    /** Modified paths (for save/update hooks) */
+    modifiedPaths?: string[];
+}
+declare class MiddlewareError extends Error {
+    readonly hookType: HookType;
+    readonly phase: 'pre' | 'post';
+    readonly originalError?: Error | undefined;
+    constructor(message: string, hookType: HookType, phase: 'pre' | 'post', originalError?: Error | undefined);
+}
+/**
+ * Manages and executes pre and post hooks for a specific hook type
+ */
+declare class MiddlewareChain {
+    readonly hookType: HookType;
+    private _preHooks;
+    private _postHooks;
+    private _errorPostHooks;
+    constructor(hookType: HookType);
+    /**
+     * Add a pre hook to the chain
+     */
+    addPre(fn: Function, options?: MiddlewareOptions): this;
+    /**
+     * Add a post hook to the chain
+     */
+    addPost(fn: Function, options?: MiddlewareOptions): this;
+    /**
+     * Add an error-handling post hook
+     * Error post hooks receive (error, doc, next) and can handle or re-throw errors
+     */
+    addPostError(fn: Function, options?: MiddlewareOptions): this;
+    /**
+     * Get all pre hooks
+     */
+    getPreHooks(): MiddlewareEntry[];
+    /**
+     * Get all post hooks
+     */
+    getPostHooks(): MiddlewareEntry[];
+    /**
+     * Run all pre hooks in sequence
+     *
+     * Hooks are executed in order. Each hook receives a next() callback.
+     * Execution stops if:
+     * - An error is thrown
+     * - An error is passed to next(err)
+     * - A hook returns a rejected Promise
+     */
+    runPre(context: HookContext): Promise<void>;
+    /**
+     * Run all post hooks in sequence
+     *
+     * Post hooks receive the result of the operation.
+     * Errors in post hooks are passed to error post hooks if available.
+     */
+    runPost(context: HookContext, result: any): Promise<any>;
+    /**
+     * Check if a hook should run based on its options and context
+     */
+    private _shouldRunHook;
+    /**
+     * Execute a single pre hook
+     */
+    private _executeHook;
+    /**
+     * Execute a single post hook
+     */
+    private _executePostHook;
+    /**
+     * Run error post hooks to handle errors from post hooks
+     */
+    private _runErrorPostHooks;
+    /**
+     * Clear all hooks
+     */
+    clear(): void;
+}
+/**
+ * Manages all middleware chains for a schema
+ */
+declare class MiddlewareManager {
+    private _chains;
+    /**
+     * Get or create a middleware chain for a hook type
+     */
+    getChain(hookType: HookType): MiddlewareChain;
+    /**
+     * Check if there are any hooks for a given type
+     */
+    hasHooks(hookType: HookType): boolean;
+    /**
+     * Create from a Schema's hook storage
+     */
+    static fromSchema(schema: Schema<any>): MiddlewareManager;
+}
+/**
+ * Execute pre hooks from a schema for a given hook type
+ *
+ * @param schema - The schema containing the hooks
+ * @param hookType - The type of hook to execute
+ * @param context - The execution context
+ */
+declare function executePreHooks(schema: Schema<any>, hookType: HookType, context: HookContext): Promise<void>;
+/**
+ * Execute post hooks from a schema for a given hook type
+ *
+ * @param schema - The schema containing the hooks
+ * @param hookType - The type of hook to execute
+ * @param context - The execution context
+ * @param result - The result of the operation
+ * @returns The potentially modified result
+ */
+declare function executePostHooks<R>(schema: Schema<any>, hookType: HookType, context: HookContext, result: R): Promise<R>;
+/**
+ * Execute both pre and post hooks around an operation
+ *
+ * @param schema - The schema containing the hooks
+ * @param hookType - The type of hook to execute
+ * @param context - The execution context
+ * @param operation - The operation to execute between pre and post hooks
+ * @returns The result of the operation
+ */
+declare function executeWithHooks<R>(schema: Schema<any>, hookType: HookType, context: HookContext, operation: () => R | Promise<R>): Promise<R>;
+/**
+ * Create a hook context for document operations
+ */
+declare function createDocumentContext(document: any, options?: {
+    isNew?: boolean;
+    modifiedPaths?: string[];
+    model?: any;
+}): HookContext;
+/**
+ * Create a hook context for query operations
+ */
+declare function createQueryContext(query: any, options?: {
+    model?: any;
+    options?: Record<string, any>;
+}): HookContext;
+/**
+ * Create a hook context for aggregate operations
+ */
+declare function createAggregateContext(pipeline: any[], options?: {
+    model?: any;
+    options?: Record<string, any>;
+}): HookContext;
+/**
+ * Create a hook context for model operations (like insertMany)
+ */
+declare function createModelContext(model: any, options?: {
+    documents?: any[];
+    options?: Record<string, any>;
+}): HookContext;
+/**
+ * Type guard to check if a hook type is a document hook
+ */
+declare function isDocumentHook(hookType: HookType): hookType is DocumentHookType;
+/**
+ * Type guard to check if a hook type is a query hook
+ */
+declare function isQueryHook(hookType: HookType): hookType is QueryHookType;
+/**
+ * Type guard to check if a hook type is a model hook
+ */
+declare function isModelHook(hookType: HookType): hookType is ModelHookType;
+/**
+ * Type guard to check if a hook type is an aggregate hook
+ */
+declare function isAggregateHook(hookType: HookType): hookType is AggregateHookType;
+
+/**
+ * Population System for Mondoo
+ *
+ * Handles resolving ObjectId references to full documents with support for:
+ * - Single and array ref population
+ * - Nested population (populate within populated docs)
+ * - Virtual population (reverse lookups via localField/foreignField)
+ * - Query deduplication and batch optimization
+ * - Circular reference handling
+ *
+ * @example
+ * ```typescript
+ * // Basic population
+ * const user = await User.findById(id).populate('posts')
+ *
+ * // Nested population
+ * const user = await User.findById(id).populate({
+ *   path: 'posts',
+ *   populate: { path: 'comments' }
+ * })
+ *
+ * // Virtual population (reverse lookup)
+ * const author = await Author.findById(id).populate({
+ *   path: 'books',
+ *   localField: '_id',
+ *   foreignField: 'author'
+ * })
+ * ```
+ */
+/**
+ * Options for populating a path
+ */
+interface PopulateOptions {
+    /** The path to populate */
+    path: string;
+    /** Fields to select in populated documents (projection) */
+    select?: string | string[] | Record<string, 0 | 1>;
+    /** Filter criteria for populated documents */
+    match?: Record<string, unknown>;
+    /** Override the model name from schema ref */
+    model?: string;
+    /** Additional query options (sort, limit, skip) */
+    options?: PopulateQueryOptions;
+    /** Nested population options */
+    populate?: PopulateOptions | PopulateOptions[] | string;
+    /** Force returning single doc (true) or array (false), overrides schema */
+    justOne?: boolean;
+    /** Local field for virtual population (default: path) */
+    localField?: string;
+    /** Foreign field for virtual population */
+    foreignField?: string;
+    /** Transform function applied to each populated doc */
+    transform?: (doc: unknown) => unknown;
+    /** Skip population if condition is false */
+    skip?: boolean;
+    /** Strict mode - throw if ref model not found */
+    strictPopulate?: boolean;
+    /** Limit number of populated docs per parent */
+    perDocumentLimit?: number;
+}
+/**
+ * Query options for population queries
+ */
+interface PopulateQueryOptions {
+    sort?: string | Record<string, 1 | -1>;
+    limit?: number;
+    skip?: number;
+    lean?: boolean;
+    session?: unknown;
+}
+/**
+ * Parsed population path info
+ */
+interface ParsedPopulatePath {
+    /** The path to populate */
+    path: string;
+    /** The model name for this ref */
+    modelName: string | null;
+    /** Whether this is an array of refs */
+    isArray: boolean;
+    /** Whether this is a virtual population */
+    isVirtual: boolean;
+    /** Local field for virtual population */
+    localField: string;
+    /** Foreign field for virtual population */
+    foreignField: string | null;
+    /** The full populate options */
+    options: PopulateOptions;
+}
+/**
+ * Schema-like interface for extracting ref info
+ */
+interface SchemaLike {
+    path(path: string): SchemaTypeLike | undefined;
+    virtuals(): Map<string, VirtualLike>;
+}
+/**
+ * Schema type interface for ref info
+ */
+interface SchemaTypeLike {
+    _options?: {
+        ref?: string;
+    };
+    _ref?: string;
+    _itemType?: SchemaTypeLike;
+}
+/**
+ * Virtual type interface
+ */
+interface VirtualLike {
+    options?: {
+        ref?: string;
+        localField?: string;
+        foreignField?: string;
+        justOne?: boolean;
+    };
+}
+/**
+ * Model registry interface for looking up models by name
+ */
+interface ModelRegistry {
+    get(name: string): ModelLike | undefined;
+}
+/**
+ * Model-like interface for population queries
+ */
+interface ModelLike {
+    find(filter: Record<string, unknown>, projection?: Record<string, 0 | 1>): PromiseLike<unknown[]>;
+    findOne?(filter: Record<string, unknown>, projection?: Record<string, 0 | 1>): PromiseLike<unknown | null>;
+    modelName: string;
+    schema?: SchemaLike;
+}
+/**
+ * Set the model registry for population lookups
+ * @internal
+ */
+declare function setModelRegistry(registry: ModelRegistry): void;
+/**
+ * Populate documents with referenced documents
+ *
+ * This is the main entry point for population. It handles:
+ * - Single documents or arrays of documents
+ * - Multiple populate paths
+ * - Batch optimization (one query per ref model)
+ * - Query deduplication
+ *
+ * @param docs - Document(s) to populate
+ * @param paths - Population options (string, object, or array)
+ * @param schema - Schema for resolving refs
+ * @param options - Additional options
+ * @returns The populated document(s)
+ *
+ * @example
+ * ```typescript
+ * // Populate a single path
+ * const populated = await populate(user, 'posts', schema)
+ *
+ * // Populate multiple paths
+ * const populated = await populate(user, ['posts', 'friends'], schema)
+ *
+ * // Populate with options
+ * const populated = await populate(user, {
+ *   path: 'posts',
+ *   select: 'title content',
+ *   match: { published: true },
+ *   options: { sort: { createdAt: -1 }, limit: 10 }
+ * }, schema)
+ * ```
+ */
+declare function populate<T>(docs: T | T[], paths: string | string[] | PopulateOptions | PopulateOptions[], schema?: SchemaLike, options?: {
+    session?: unknown;
+}): Promise<T | T[]>;
+/**
+ * Collect all paths that need to be populated from a schema and options
+ *
+ * This helper parses populate options and resolves them against a schema
+ * to get the full list of paths and their configurations.
+ *
+ * @param schema - The schema to check for refs
+ * @param options - The populate options
+ * @returns Array of parsed populate paths
+ */
+declare function collectPopulatePaths(schema: SchemaLike | undefined, options: string | string[] | PopulateOptions | PopulateOptions[]): ParsedPopulatePath[];
+/**
+ * Resolve the referenced model name for a schema path
+ *
+ * @param schema - The schema to check
+ * @param path - The path to check for ref
+ * @returns The model name or null if not found
+ */
+declare function resolveRefModel(schema: SchemaLike | undefined, path: string): string | null;
+/**
+ * Assign populated documents back to the parent documents
+ *
+ * This is a helper for manual population assignment when you have
+ * already fetched the documents separately.
+ *
+ * @param docs - The parent documents to assign to
+ * @param path - The path to assign at
+ * @param fetchedDocs - Map of ID -> fetched document
+ * @param options - Population options
+ */
+declare function assignPopulated(docs: unknown[], path: string, fetchedDocs: Map<string, unknown>, options?: {
+    isArray?: boolean;
+    justOne?: boolean;
+}): void;
+/**
+ * Depopulate a path on documents - restore original ObjectId values
+ *
+ * @param docs - Documents to depopulate
+ * @param path - Path to depopulate (or all if not specified)
+ */
+declare function depopulate(docs: unknown | unknown[], path?: string): void;
+/**
+ * Check if a path on a document is currently populated
+ *
+ * @param doc - Document to check
+ * @param path - Path to check
+ * @returns true if the path is populated with a document/documents
+ */
+declare function isPopulated(doc: unknown, path: string): boolean;
+
+/**
+ * Connection adapter for Mondoo - adapts mondoo for Cloudflare Workers with capnweb
+ */
+
+/**
+ * Durable Object Namespace binding type
+ * This is a simplified type - the actual type comes from @cloudflare/workers-types
+ */
+interface DurableObjectNamespace {
+    newUniqueId(options?: {
+        jurisdiction?: string;
+    }): DurableObjectId;
+    idFromName(name: string): DurableObjectId;
+    idFromString(id: string): DurableObjectId;
+    get(id: DurableObjectId): DurableObjectStub;
+}
+interface DurableObjectId {
+    toString(): string;
+    equals(other: DurableObjectId): boolean;
+}
+interface DurableObjectStub {
+    id: DurableObjectId;
+    name?: string;
+    fetch(request: Request | string, init?: RequestInit): Promise<Response>;
+}
+/**
+ * Connection ready states (compatible with Mongoose)
+ */
+declare const STATES: {
+    readonly disconnected: 0;
+    readonly connected: 1;
+    readonly connecting: 2;
+    readonly disconnecting: 3;
+};
+type ConnectionState = typeof STATES[keyof typeof STATES];
+/**
+ * Event types for connection events
+ */
+type ConnectionEventType = 'connected' | 'disconnected' | 'error' | 'connecting' | 'disconnecting' | 'open' | 'close' | 'reconnected';
+/**
+ * Connection options
+ */
+interface ConnectionOptions {
+    /** Database name */
+    dbName?: string;
+    /** Auto create indexes on model creation */
+    autoIndex?: boolean;
+    /** Auto create collections */
+    autoCreate?: boolean;
+    /** Maximum pool size (not applicable for DO but kept for compatibility) */
+    maxPoolSize?: number;
+    /** Minimum pool size */
+    minPoolSize?: number;
+    /** Buffer commands when disconnected */
+    bufferCommands?: boolean;
+}
+/**
+ * Cloudflare Worker environment interface
+ * This defines the expected shape of the Worker env object
+ */
+interface WorkerEnv {
+    /** The Durable Object binding for mondodb */
+    MONDODB?: DurableObjectNamespace;
+    /** Alternative binding names */
+    DB?: DurableObjectNamespace;
+    DATABASE?: DurableObjectNamespace;
+    /** Any other DO bindings */
+    [key: string]: unknown;
+}
+/**
+ * Session options for transactions
+ */
+interface SessionOptions {
+    /** Default transaction options */
+    defaultTransactionOptions?: {
+        readConcern?: {
+            level: string;
+        };
+        writeConcern?: {
+            w: number | string;
+        };
+    };
+}
+/**
+ * Client session for transactions (placeholder)
+ */
+interface ClientSession {
+    /** Session ID */
+    id: string;
+    /** Whether the session is in a transaction */
+    inTransaction(): boolean;
+    /** Start a transaction */
+    startTransaction(options?: Record<string, unknown>): void;
+    /** Commit the transaction */
+    commitTransaction(): Promise<void>;
+    /** Abort the transaction */
+    abortTransaction(): Promise<void>;
+    /** End the session */
+    endSession(): Promise<void>;
+    /** Run a callback in a transaction */
+    withTransaction<T>(fn: () => Promise<T>, options?: Record<string, unknown>): Promise<T>;
+}
+type EventListener = (...args: unknown[]) => void;
+/**
+ * Simple EventEmitter implementation for connection events
+ * Uses native EventTarget internally but provides Node.js-style API
+ */
+declare class SimpleEventEmitter {
+    private _listeners;
+    /**
+     * Add an event listener
+     */
+    on(event: string, listener: EventListener): this;
+    /**
+     * Add a one-time event listener
+     */
+    once(event: string, listener: EventListener): this;
+    /**
+     * Remove an event listener
+     */
+    off(event: string, listener: EventListener): this;
+    /**
+     * Remove all listeners for an event (or all events if no event specified)
+     */
+    removeAllListeners(event?: string): this;
+    /**
+     * Emit an event
+     */
+    emit(event: string, ...args: unknown[]): boolean;
+    /**
+     * Get the number of listeners for an event
+     */
+    listenerCount(event: string): number;
+    /**
+     * Get all listeners for an event
+     */
+    listeners(event: string): EventListener[];
+    /**
+     * Alias for on()
+     */
+    addListener(event: string, listener: EventListener): this;
+    /**
+     * Alias for off()
+     */
+    removeListener(event: string, listener: EventListener): this;
+}
+/**
+ * Connection class for managing database connections
+ * Adapts mondoo for Cloudflare Workers with Durable Objects
+ */
+declare class Connection extends SimpleEventEmitter {
+    /** Current ready state */
+    private _readyState;
+    /** Registered models for this connection */
+    private _models;
+    /** Database reference (placeholder for mondodb DO) */
+    private _db;
+    /** Database name */
+    private _name;
+    /** Connection options */
+    private _options;
+    /** Worker environment reference */
+    private _env;
+    /** The host (for Mongoose compatibility) */
+    private _host;
+    /** The port (for Mongoose compatibility) */
+    private _port;
+    /** Connection URI (for Mongoose compatibility) */
+    private _uri;
+    /** Buffer for commands issued before connection is ready */
+    private _commandBuffer;
+    /**
+     * Get the current ready state
+     */
+    get readyState(): ConnectionState;
+    /**
+     * Get registered models
+     */
+    get models(): Map<string, ModelConstructor<any>>;
+    /**
+     * Get database reference
+     */
+    get db(): unknown;
+    /**
+     * Get database name
+     */
+    get name(): string;
+    /**
+     * Get the host
+     */
+    get host(): string;
+    /**
+     * Get the port
+     */
+    get port(): number;
+    /**
+     * Get connection options
+     */
+    get options(): ConnectionOptions;
+    /**
+     * Alias for models property (Mongoose compatibility)
+     */
+    get collections(): Map<string, ModelConstructor<any>>;
+    /**
+     * Open a connection
+     * In Workers context, this validates the environment is set up
+     */
+    openUri(uri?: string, options?: ConnectionOptions): Promise<this>;
+    /**
+     * Set the Worker environment - this is the primary way to connect in Workers
+     */
+    useEnv(env: WorkerEnv): this;
+    /**
+     * Get the Worker environment
+     */
+    getEnv(): WorkerEnv | null;
+    /**
+     * Close the connection
+     */
+    close(force?: boolean): Promise<void>;
+    /**
+     * Alias for close
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Extract database name from URI
+     */
+    private _extractDbName;
+    /**
+     * Buffer a command if not connected
+     */
+    private _bufferCommand;
+    /**
+     * Flush buffered commands
+     */
+    private _flushCommandBuffer;
+    /**
+     * Register or retrieve a model
+     */
+    model<T extends Record<string, unknown> = Record<string, unknown>>(name: string, schema?: Schema<T>, collection?: string): ModelConstructor<T>;
+    /**
+     * Get all registered model names
+     */
+    modelNames(): string[];
+    /**
+     * Delete a model from the connection
+     */
+    deleteModel(name: string): this;
+    /**
+     * Check if a model exists
+     */
+    hasModel(name: string): boolean;
+    /**
+     * Start a session for transactions
+     * Note: This is a placeholder - actual implementation depends on mondodb
+     */
+    startSession(options?: SessionOptions): Promise<ClientSession>;
+    /**
+     * Run a function within a transaction
+     */
+    transaction<T>(fn: (session: ClientSession) => Promise<T>, options?: SessionOptions): Promise<T>;
+    /**
+     * Set a connection option
+     */
+    set(key: keyof ConnectionOptions, value: unknown): this;
+    /**
+     * Get a connection option
+     */
+    get(key: keyof ConnectionOptions): unknown;
+    /**
+     * Create a new connection (for multiple database support)
+     */
+    createConnection(): Connection;
+    /**
+     * Get the client (Mongoose compatibility)
+     */
+    getClient(): unknown;
+    /**
+     * Set the client
+     */
+    setClient(client: unknown): this;
+    /**
+     * Sync all indexes for registered models
+     */
+    syncIndexes(options?: {
+        background?: boolean;
+    }): Promise<Record<string, string[]>>;
+    /**
+     * Drop the database
+     * Note: Placeholder - actual implementation depends on mondodb
+     */
+    dropDatabase(): Promise<void>;
+    /**
+     * List all collections
+     */
+    listCollections(): Promise<string[]>;
+    /**
+     * Get a collection by name (Mongoose compatibility)
+     */
+    collection(name: string): unknown;
+    /**
+     * Watch for changes (Mongoose compatibility)
+     */
+    watch(pipeline?: Record<string, unknown>[], options?: Record<string, unknown>): unknown;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Asynchronously iterate over models
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<[string, ModelConstructor<any>]>;
+}
+/**
+ * Create a mondoo instance configured for a Cloudflare Worker
+ * This is the recommended way to use mondoo in Workers
+ *
+ * @example
+ * ```typescript
+ * // In your Worker
+ * export default {
+ *   async fetch(request: Request, env: Env) {
+ *     const mondoo = createMondoo(env)
+ *
+ *     const User = mondoo.model('User', userSchema)
+ *     const users = await User.find()
+ *
+ *     return Response.json(users)
+ *   }
+ * }
+ * ```
+ */
+declare function createMondoo(env: WorkerEnv, options?: ConnectionOptions): Connection;
+/**
+ * Connect to database (Mongoose-compatible API)
+ * In Workers, this is mainly for API compatibility - use createMondoo() instead
+ */
+declare function connect(uri?: string, options?: ConnectionOptions): Promise<Connection>;
+/**
+ * Disconnect from database
+ */
+declare function disconnect(): Promise<void>;
+/**
+ * The default connection instance
+ * This mimics mongoose.connection
+ */
+declare const defaultConnection: Connection;
+/**
+ * Alias for defaultConnection (mongoose.connection pattern)
+ */
+declare const connection: Connection;
+
+/**
+ * The main mondoo export - mimics mongoose's default export
+ */
+declare const mondoo: {
+    $: {
+        string: () => StringType<false>;
+        number: () => NumberType<false>;
+        boolean: () => BooleanType<false>;
+        date: () => DateType<false>;
+        objectId: () => ObjectIdType<false, never>;
+        buffer: () => BufferType<false>;
+        bigint: () => BigIntType<false>;
+        array: <T>(itemType: SchemaType<T, any>) => ArrayType<T, false>;
+        object: <T extends Record<string, SchemaType<any, any>>>(shape: T) => ObjectType<T, false>;
+        map: <T>(valueType: SchemaType<T, any>) => MapType<T, false>;
+        enum: <T extends readonly string[]>(values: T) => EnumType<T, false>;
+        literal: <T extends string | number | boolean>(value: T) => LiteralType<T, false>;
+        mixed: () => MixedType<false>;
+        any: () => MixedType<false>;
+        schema: <T extends Record<string, SchemaType<any, any>>>(shape: T, options?: SchemaOptions) => Schema<InferObject<T>>;
+        infer: <T extends Schema<any>>() => T extends Schema<infer U> ? U : never;
+        input: <T extends Schema<any>>() => T extends Schema<infer U> ? U : never;
+        output: <T extends Schema<any>>() => T extends Schema<infer U> ? U : never;
+    };
+    Schema: typeof Schema;
+    Document: typeof Document;
+    Model: typeof Model;
+    Query: typeof Query;
+    Aggregate: typeof Aggregate;
+    Connection: typeof Connection;
+    Types: {
+        String: StringConstructor;
+        Number: NumberConstructor;
+        Boolean: BooleanConstructor;
+        Date: DateConstructor;
+        ObjectId: "ObjectId";
+        Buffer: "Buffer";
+        Mixed: "Mixed";
+        Array: ArrayConstructor;
+        Map: MapConstructor;
+        BigInt: BigIntConstructor;
+    };
+    model: typeof model;
+    getModel: typeof getModel;
+    hasModel: typeof hasModel;
+    deleteModel: typeof deleteModel;
+    modelNames: typeof modelNames;
+    createMondoo: typeof createMondoo;
+    connect: typeof connect;
+    disconnect: typeof disconnect;
+    connection: Connection;
+    STATES: {
+        readonly disconnected: 0;
+        readonly connected: 1;
+        readonly connecting: 2;
+        readonly disconnecting: 3;
+    };
+    populate: typeof populate;
+    version: string;
+};
+
+export { $, Aggregate, AggregateCursor, type AggregateHookType, type AggregateOptions, ArrayType, BigIntType, BooleanType, type BucketAutoOptions, type BucketOptions, BufferType, type BulkWriteOperation, type BulkWriteResult, type ClientSession, Connection, type ConnectionEventType, type ConnectionOptions, type ConnectionState, DateType, type DeleteResult, Document, type DocumentHookType, type DocumentInternal, EnumType, type GeoNearOptions, type GraphLookupOptions, type HookType, type InferObject, type InferSchema, type InferSchemaType, LiteralType, type LookupOptions, MapType, type MergeOptions, MiddlewareChain, MiddlewareError, MiddlewareManager, MixedType, Model, type ModelConstructor, type ModelHookType, MongooseValidationError, NumberType, ObjectIdType, ObjectType, type PopulateOptions$1 as PopulateOptions, type PopulatedDoc, type PopulateOptions as PopulationOptions, type PostHookFn, type PreHookFn, Query, QueryCursor, type QueryHookType, type QueryOptions, STATES, type SampleOptions, Schema, type SchemaDefinition, type SchemaOptions$1 as SchemaOptions, SchemaType, type SchemaTypeOptions, type SessionOptions, StringType, type ToObjectOptions, Types, type UnionWithOptions, type UnwindOptions, type UpdateResult, type ValidationError, type WorkerEnv, assignPopulated, collectPopulatePaths, connect, connection, createAggregateContext, createDocumentContext, createModelContext, createMondoo, createQueryContext, mondoo as default, defaultConnection, deleteModel, depopulate, disconnect, executePostHooks, executePreHooks, executeWithHooks, getModel, hasModel, isAggregateHook, isDocumentHook, isModelHook, isPopulated, isQueryHook, model, modelNames, populate, resolveRefModel, setModelRegistry };