@fyrestack/database 0.1.0 → 0.1.2

package/dist/index.d.cts

@@ -0,0 +1,1071 @@
+import { OmitPrivate, Prettify, Type } from "@fyrestack/core";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/batch.d.ts
+/**
+ * Maximum operations per Firestore batch.
+ */
+declare const MAX_BATCH_SIZE = 500;
+/**
+ * Run operations within a write batch.
+ *
+ * Batches provide:
+ * - Atomic writes (all succeed or all fail)
+ * - Better performance than individual writes
+ * - Up to 500 operations per batch
+ * - Works across multiple repositories
+ *
+ * The batch context is **automatically propagated** to all repository
+ * methods called within the batch function - no need to pass context explicitly.
+ *
+ * Note: Batches are write-only. Use `runTransaction` if you need reads.
+ *
+ * @example
+ * ```typescript
+ * // Bulk create users
+ * await writeBatch(async () => {
+ *   for (const user of users) {
+ *     await UserRepo.save({}, user);
+ *   }
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Cross-repository batch write
+ * await writeBatch(async () => {
+ *   await UserRepo.save({}, user);
+ *   await ProfileRepo.save({ userId: user.id }, profile);
+ *   await AuditRepo.save({}, auditLog);
+ * });
+ * ```
+ *
+ * @param fn - Async function to run within the batch
+ */
+declare function writeBatch(fn: () => Promise<void>): Promise<void>;
+/**
+ * Run operations with automatic batch chunking for large datasets.
+ *
+ * Automatically commits and creates new batches when exceeding 500 operations.
+ * Useful for migrations or bulk imports with thousands of records.
+ *
+ * The batch context is **automatically propagated** to all repository
+ * methods called within the function.
+ *
+ * @example
+ * ```typescript
+ * // Process 10,000 records with automatic batching
+ * await writeChunkedBatch(async () => {
+ *   for (const user of thousandsOfUsers) {
+ *     await UserRepo.save({}, user);
+ *     // Automatically commits every 500 operations
+ *   }
+ * });
+ * ```
+ *
+ * @param fn - Function to run with automatic batch chunking
+ */
+declare function writeChunkedBatch(fn: () => Promise<void>): Promise<void>;
+//#endregion
+//#region src/firestore.types.d.ts
+/**
+ * Sentinel type for server-generated timestamps.
+ * This is a branded type that represents Firebase's serverTimestamp() value.
+ */
+interface ServerTimestampSentinel {
+  /** Brand to distinguish from other objects */
+  readonly __type__: 'serverTimestamp';
+}
+/**
+ * Type guard to check if a value is a ServerTimestampSentinel.
+ * Note: This checks the runtime structure, not the brand.
+ */
+declare function isServerTimestamp(value: unknown): value is ServerTimestampSentinel;
+/**
+ * Abstract document snapshot
+ */
+interface DocumentSnapshot<T = unknown> {
+  id: string;
+  exists: boolean;
+  data(): T | undefined;
+}
+/**
+ * Abstract document reference
+ */
+interface DocumentReference<T = unknown> {
+  id: string;
+  path: string;
+  /** Native reference for transaction/batch operations (internal use) */
+  _native?: unknown;
+  get(): Promise<DocumentSnapshot<T>>;
+  set(data: T): Promise<void>;
+  update(data: Record<string, unknown>): Promise<void>;
+  delete(): Promise<void>;
+}
+/**
+ * Abstract query snapshot
+ */
+interface QuerySnapshot<T = unknown> {
+  docs: DocumentSnapshot<T>[];
+  empty: boolean;
+  size: number;
+}
+/**
+ * Supported Firestore operators
+ */
+type WhereFilterOp = '<' | '<=' | '==' | '!=' | '>=' | '>' | 'array-contains' | 'array-contains-any' | 'in' | 'not-in';
+/**
+ * Sort direction
+ */
+type OrderByDirection = 'asc' | 'desc';
+/**
+ * Abstract query reference - chainable query builder
+ */
+interface QueryReference<T = unknown> {
+  where(field: string, op: WhereFilterOp, value: unknown): QueryReference<T>;
+  orderBy(field: string, direction?: OrderByDirection): QueryReference<T>;
+  limit(count: number): QueryReference<T>;
+  startAt(...values: unknown[]): QueryReference<T>;
+  startAfter(...values: unknown[]): QueryReference<T>;
+  endAt(...values: unknown[]): QueryReference<T>;
+  endBefore(...values: unknown[]): QueryReference<T>;
+  get(): Promise<QuerySnapshot<T>>;
+}
+/**
+ * Abstract collection reference
+ */
+interface CollectionReference<T = unknown> extends QueryReference<T> {
+  path: string;
+  doc(id?: string): DocumentReference<T>;
+}
+/**
+ * Options for running a transaction.
+ */
+interface TransactionOptions {
+  /** Maximum retry attempts on contention (default: 5) */
+  maxAttempts?: number;
+}
+/**
+ * Firestore Transaction handle for atomic read-write operations.
+ * All reads must happen before writes within a transaction.
+ */
+interface Transaction {
+  /**
+   * Read a document within the transaction.
+   */
+  get<T>(docRef: DocumentReference<T>): Promise<DocumentSnapshot<T>>;
+  /**
+   * Set a document within the transaction.
+   */
+  set<T>(docRef: DocumentReference<T>, data: T): Transaction;
+  /**
+   * Update a document within the transaction.
+   */
+  update(docRef: DocumentReference, data: Record<string, unknown>): Transaction;
+  /**
+   * Delete a document within the transaction.
+   */
+  delete(docRef: DocumentReference): Transaction;
+}
+/**
+ * Firestore WriteBatch handle for atomic write-only operations.
+ * Up to 500 operations per batch.
+ */
+interface WriteBatch {
+  /**
+   * Set a document in the batch.
+   */
+  set<T>(docRef: DocumentReference<T>, data: T): WriteBatch;
+  /**
+   * Update a document in the batch.
+   */
+  update(docRef: DocumentReference, data: Record<string, unknown>): WriteBatch;
+  /**
+   * Delete a document in the batch.
+   */
+  delete(docRef: DocumentReference): WriteBatch;
+  /**
+   * Commit all batched operations atomically.
+   */
+  commit(): Promise<void>;
+}
+/**
+ * Abstract Firestore instance - the main DI interface
+ */
+interface FirestoreAdapter {
+  collection<T = unknown>(path: string): CollectionReference<T>;
+  doc<T = unknown>(path: string): DocumentReference<T>;
+  /**
+   * Returns a sentinel value for server-generated timestamp.
+   * Used for createdAt/updatedAt fields.
+   *
+   * Note: Returns the actual Firebase sentinel value which is cast to
+   * ServerTimestampSentinel for type safety. The runtime value is
+   * Firebase's internal FieldValue/serverTimestamp implementation.
+   */
+  serverTimestamp(): ServerTimestampSentinel;
+  /**
+   * Run a transaction with automatic retry on conflicts.
+   * @param updateFn - Function receiving Transaction object
+   * @param options - Transaction options (maxAttempts, etc.)
+   */
+  runTransaction<T>(updateFn: (transaction: Transaction) => Promise<T>, options?: TransactionOptions): Promise<T>;
+  /**
+   * Create a new write batch.
+   */
+  batch(): WriteBatch;
+}
+/**
+ * Set the Firestore adapter to use (call once at app initialization)
+ */
+declare function setFirestoreAdapter(adapter: FirestoreAdapter): void;
+/**
+ * Get the current Firestore adapter
+ * @throws AdapterNotInitializedError if adapter not initialized
+ */
+declare function getFirestoreAdapter(): FirestoreAdapter;
+/**
+ * Reset the Firestore adapter (for testing only)
+ * @internal
+ */
+declare function _resetFirestoreAdapter(): void;
+//#endregion
+//#region src/context.d.ts
+/**
+ * Transaction context - supports reads and writes.
+ */
+interface TransactionContext {
+  readonly type: 'transaction';
+  readonly tx: Transaction;
+}
+/**
+ * Batch context - write-only operations.
+ */
+interface BatchContext {
+  readonly type: 'batch';
+  readonly batch: WriteBatch;
+}
+/**
+ * Union of all operation contexts.
+ */
+type OperationContext = TransactionContext | BatchContext;
+/**
+ * Get the current operation context, if any.
+ * Returns undefined when not inside a transaction or batch.
+ */
+declare function getCurrentContext(): OperationContext | undefined;
+/**
+ * Check if we're currently inside a transaction.
+ */
+declare function isInTransaction(): boolean;
+/**
+ * Check if we're currently inside a batch.
+ */
+declare function isInBatch(): boolean;
+/**
+ * Get the current transaction, if inside one.
+ * Returns undefined when not in a transaction.
+ */
+declare function getCurrentTransaction(): Transaction | undefined;
+/**
+ * Get the current batch, if inside one.
+ * Returns undefined when not in a batch.
+ */
+declare function getCurrentBatch(): WriteBatch | undefined;
+/**
+ * Run a function within a transaction context.
+ * @internal Used by runTransaction()
+ */
+declare function runWithTransaction<T>(tx: Transaction, fn: () => Promise<T>): Promise<T>;
+/**
+ * Run a function within a batch context.
+ * @internal Used by writeBatch()
+ */
+declare function runWithBatch<T>(batch: WriteBatch, fn: () => Promise<T>): Promise<T>;
+/**
+ * Type guard for transaction context.
+ */
+declare function isTransactionContext(ctx?: OperationContext): ctx is TransactionContext;
+/**
+ * Type guard for batch context.
+ */
+declare function isBatchContext(ctx?: OperationContext): ctx is BatchContext;
+//#endregion
+//#region src/errors.d.ts
+/**
+ * FyreStack Custom Error Types
+ *
+ * Provides typed errors for better error handling and debugging.
+ */
+/**
+ * Base error class for all FyreStack errors.
+ */
+declare class FyreStackError extends Error {
+  readonly code: string;
+  constructor(message: string, code: string);
+}
+/**
+ * Error thrown when validation fails.
+ */
+declare class ValidationError extends FyreStackError {
+  readonly issues: ValidationIssue[];
+  constructor(message: string, issues?: ValidationIssue[]);
+  /**
+   * Create a ValidationError from Standard Schema validation issues.
+   */
+  static fromStandardSchema(issues: readonly StandardSchemaIssue[]): ValidationError;
+}
+/**
+ * Validation issue structure.
+ */
+interface ValidationIssue {
+  /** Path to the invalid field (e.g., ['address', 'zip']) */
+  path: string[];
+  /** Human-readable error message */
+  message: string;
+}
+/**
+ * Standard Schema issue structure (subset of StandardSchemaV1).
+ * Compatible with the path types from @standard-schema/spec.
+ */
+interface StandardSchemaIssue {
+  message: string;
+  path?: ReadonlyArray<PropertyKey | {
+    key: PropertyKey;
+  }> | undefined;
+}
+/**
+ * Error thrown when path parameters are invalid.
+ */
+declare class PathParamError extends FyreStackError {
+  readonly paramName: string;
+  readonly paramValue: string;
+  constructor(paramName: string, paramValue: string, reason: string);
+}
+/**
+ * Error thrown when Firestore adapter is not initialized.
+ */
+declare class AdapterNotInitializedError extends FyreStackError {
+  constructor();
+}
+/**
+ * Error thrown when a model is missing required properties.
+ */
+declare class ModelError extends FyreStackError {
+  constructor(message: string);
+}
+/**
+ * Error thrown when a document is not found.
+ */
+declare class NotFoundError extends FyreStackError {
+  readonly documentPath: string;
+  constructor(documentPath: string);
+}
+/**
+ * Error thrown when a Firestore operation fails.
+ */
+declare class FirestoreError extends FyreStackError {
+  readonly originalError: unknown;
+  constructor(message: string, originalError: unknown);
+  /**
+   * Wrap a Firestore error with context.
+   */
+  static wrap(operation: string, error: unknown): FirestoreError;
+}
+/**
+ * Validation result type for type-safe validation handling.
+ */
+type ValidationResult<T> = {
+  valid: true;
+  value: T;
+} | {
+  valid: false;
+  error: ValidationError;
+};
+/**
+ * Helper to check if a ValidationResult is valid.
+ */
+declare function isValidResult<T>(result: ValidationResult<T>): result is {
+  valid: true;
+  value: T;
+};
+//#endregion
+//#region src/model.hooks.d.ts
+/**
+ * Context passed to repository hooks during operations.
+ * Provides access to the adapter, model info, and operation details.
+ */
+interface RepositoryHookContext {
+  /** The Firestore adapter for accessing Firebase functionality */
+  adapter: FirestoreAdapter;
+  /** The model class being operated on */
+  modelClass: Type<unknown>;
+  /** The collection path template */
+  path: string;
+  /** The resolved path parameters */
+  params: Record<string, string>;
+  /** The document ID (if applicable) */
+  id?: string;
+}
+/**
+ * Context passed to model hooks during construction/validation.
+ */
+interface ModelHookContext {
+  /** The model class being constructed */
+  modelClass: Type<unknown>;
+}
+/**
+ * Hooks that can be registered for model lifecycle events.
+ */
+interface ModelHooks {
+  /**
+   * Called during model construction, can transform props.
+   * @param props - The properties being assigned to the model
+   * @param context - Model context
+   * @returns Transformed props
+   */
+  onConstruct?: (props: Record<string, unknown>, context: ModelHookContext) => Record<string, unknown>;
+  /**
+   * Called during model validation.
+   * Can throw ValidationError to fail validation.
+   * @param data - The data being validated
+   * @param context - Model context
+   */
+  onValidate?: (data: unknown, context: ModelHookContext) => void;
+}
+/**
+ * Hooks that can be registered for repository operations.
+ * Hooks can transform data or perform side effects.
+ */
+interface RepositoryHooks {
+  /**
+   * Called before save operation.
+   * Can modify the data being saved.
+   * @param data - The data to be saved
+   * @param context - Repository context with adapter access
+   * @returns Modified data (or original if unchanged)
+   */
+  beforeSave?: (data: Record<string, unknown>, context: RepositoryHookContext) => Record<string, unknown>;
+  /**
+   * Called after save operation completes successfully.
+   * @param data - The data that was saved
+   * @param context - Repository context
+   */
+  afterSave?: (data: Record<string, unknown>, context: RepositoryHookContext) => void;
+  /**
+   * Called before update operation.
+   * Can modify the update data (dot-notation fields).
+   * @param updates - The update data
+   * @param context - Repository context with adapter access
+   * @returns Modified updates (or original if unchanged)
+   */
+  beforeUpdate?: (updates: Record<string, unknown>, context: RepositoryHookContext) => Record<string, unknown>;
+  /**
+   * Called after update operation completes successfully.
+   * @param updates - The update data that was applied
+   * @param context - Repository context
+   */
+  afterUpdate?: (updates: Record<string, unknown>, context: RepositoryHookContext) => void;
+  /**
+   * Called before delete operation.
+   * Can throw to prevent deletion.
+   * @param context - Repository context
+   */
+  beforeDelete?: (context: RepositoryHookContext) => void;
+  /**
+   * Called after delete operation completes successfully.
+   * @param context - Repository context
+   */
+  afterDelete?: (context: RepositoryHookContext) => void;
+  /**
+   * Called after get operation, can transform the result.
+   * @param data - The fetched data (or null if not found)
+   * @param context - Repository context
+   * @returns Transformed data
+   */
+  afterGet?: (data: Record<string, unknown> | null, context: RepositoryHookContext) => Record<string, unknown> | null;
+  /**
+   * Called after find operation, can transform results.
+   * @param data - Array of fetched documents
+   * @param context - Repository context
+   * @returns Transformed array
+   */
+  afterFind?: (data: Record<string, unknown>[], context: RepositoryHookContext) => Record<string, unknown>[];
+}
+/**
+ * Combined hooks for both model and repository lifecycle.
+ */
+interface FeatureHooks {
+  /** Hooks for model lifecycle events */
+  model?: ModelHooks;
+  /** Hooks for repository operations */
+  repository?: RepositoryHooks;
+}
+/**
+ * Merge multiple repository hooks into a single hooks object.
+ * When multiple hooks define the same method, they are chained in order.
+ */
+declare function mergeRepositoryHooks(...hooksList: (RepositoryHooks | undefined)[]): RepositoryHooks;
+/**
+ * Merge multiple model hooks into a single hooks object.
+ */
+declare function mergeModelHooks(...hooksList: (ModelHooks | undefined)[]): ModelHooks;
+/**
+ * Merge feature hooks (combines both model and repository hooks).
+ */
+declare function mergeFeatureHooks(...hooksList: (FeatureHooks | undefined)[]): FeatureHooks;
+//#endregion
+//#region src/model.metadata.d.ts
+/**
+ * Symbol used to store metadata on model classes.
+ * Using a symbol prevents conflicts with user-defined properties.
+ */
+declare const MODEL_METADATA: unique symbol;
+/**
+ * Model metadata containing registered feature hooks.
+ * This is stored on the model class and read by repositories.
+ */
+interface ModelMetadata {
+  /**
+   * Combined hooks from all registered features.
+   */
+  hooks?: FeatureHooks;
+  /**
+   * Feature-specific configuration data.
+   * Features can store their config here for introspection.
+   */
+  features?: Record<string, unknown>;
+}
+/**
+ * Get metadata from a model class.
+ */
+declare function getModelMetadata(ModelClass: unknown): ModelMetadata | undefined;
+/**
+ * Get repository hooks from a model class.
+ */
+declare function getRepositoryHooks(ModelClass: unknown): RepositoryHooks | undefined;
+/**
+ * Get model hooks from a model class.
+ */
+declare function getModelHooks(ModelClass: unknown): ModelHooks | undefined;
+/**
+ * Check if a model has any repository hooks registered.
+ */
+declare function hasRepositoryHooks(ModelClass: unknown): boolean;
+/**
+ * Check if a model has a specific feature registered.
+ */
+declare function hasFeature(ModelClass: unknown, featureName: string): boolean;
+/**
+ * Get configuration for a specific feature.
+ */
+declare function getFeatureConfig<T>(ModelClass: unknown, featureName: string): T | undefined;
+/**
+ * Create metadata for a feature.
+ * Used by feature functions like withTimestamps() to build metadata.
+ *
+ * @param featureName - Unique name for the feature
+ * @param config - Feature-specific configuration (for introspection)
+ * @param hooks - Hooks to register
+ * @param existingMetadata - Existing metadata to merge with
+ */
+declare function createFeatureMetadata(featureName: string, config: unknown, hooks: FeatureHooks, existingMetadata?: ModelMetadata): ModelMetadata;
+/**
+ * Configuration for automatic timestamp management.
+ */
+interface TimestampsConfig {
+  /**
+   * Field name for creation timestamp.
+   * Set to `false` to disable.
+   * @default 'createdAt'
+   */
+  createdAt: string | false;
+  /**
+   * Field name for last update timestamp.
+   * Set to `false` to disable.
+   * @default 'updatedAt'
+   */
+  updatedAt: string | false;
+  /**
+   * Whether to use Firestore serverTimestamp() for accuracy.
+   * When false, uses client-side Date.
+   * @default true
+   */
+  useServerTimestamp: boolean;
+}
+/**
+ * User-provided options for configuring timestamps.
+ * All fields are optional with sensible defaults.
+ */
+interface TimestampsOptions {
+  /**
+   * Field name for creation timestamp, or `false` to disable.
+   * @default 'createdAt'
+   */
+  createdAt?: string | false;
+  /**
+   * Field name for last update timestamp, or `false` to disable.
+   * @default 'updatedAt'
+   */
+  updatedAt?: string | false;
+  /**
+   * Whether to use Firestore serverTimestamp().
+   * @default true
+   */
+  useServerTimestamp?: boolean;
+}
+/**
+ * Default timestamp configuration.
+ */
+declare const DEFAULT_TIMESTAMPS: TimestampsConfig;
+/**
+ * Configuration for audit trail management.
+ * Tracks which user created/modified documents.
+ */
+interface AuditConfig {
+  /**
+   * Field name for creator user ID.
+   * Set to `false` to disable.
+   * @default 'createdBy'
+   */
+  createdBy: string | false;
+  /**
+   * Field name for last modifier user ID.
+   * Set to `false` to disable.
+   * @default 'updatedBy'
+   */
+  updatedBy: string | false;
+  /**
+   * Function to get the current user ID.
+   * Must be provided when using audit feature.
+   */
+  getCurrentUserId: () => string | null;
+}
+/**
+ * User-provided options for configuring audit trail.
+ */
+interface AuditOptions {
+  createdBy?: string | false;
+  updatedBy?: string | false;
+  getCurrentUserId: () => string | null;
+}
+/**
+ * Default audit configuration.
+ */
+declare const DEFAULT_AUDIT: Omit<AuditConfig, 'getCurrentUserId'>;
+/**
+ * Configuration for status field management including soft-delete.
+ */
+interface StatusConfig {
+  /**
+   * Field name for status.
+   * @default 'status'
+   */
+  field: string;
+  /**
+   * Available status values.
+   * @default ['active', 'inactive', 'deleted']
+   */
+  values: readonly string[];
+  /**
+   * Default status for new documents.
+   * @default 'active'
+   */
+  defaultValue: string;
+  /**
+   * Status value that indicates soft-deletion.
+   * When set, delete operations will set this status instead of hard-deleting.
+   * @default 'deleted'
+   */
+  deletedValue: string | false;
+  /**
+   * Field name for deletion timestamp (when soft-delete is enabled).
+   * @default 'deletedAt'
+   */
+  deletedAt: string | false;
+}
+/**
+ * User-provided options for configuring status.
+ */
+interface StatusOptions {
+  field?: string;
+  values?: readonly string[];
+  defaultValue?: string;
+  deletedValue?: string | false;
+  deletedAt?: string | false;
+}
+/**
+ * Default status configuration.
+ */
+declare const DEFAULT_STATUS: StatusConfig;
+/**
+ * Check if a model has timestamps feature.
+ */
+declare function hasTimestamps(ModelClass: unknown): boolean;
+/**
+ * Get timestamps configuration from a model class.
+ */
+declare function getTimestampsConfig(ModelClass: unknown): TimestampsConfig | undefined;
+/**
+ * Check if a model has audit feature.
+ */
+declare function hasAudit(ModelClass: unknown): boolean;
+/**
+ * Get audit configuration from a model class.
+ */
+declare function getAuditConfig(ModelClass: unknown): AuditConfig | undefined;
+/**
+ * Check if a model has status feature.
+ */
+declare function hasStatus(ModelClass: unknown): boolean;
+/**
+ * Get status configuration from a model class.
+ */
+declare function getStatusConfig(ModelClass: unknown): StatusConfig | undefined;
+//#endregion
+//#region src/model.types.d.ts
+/**
+ * Symbol for storing the schema on model instances (internal use).
+ */
+declare const MODEL_SCHEMA: unique symbol;
+/**
+ * Infer the instance type from a Model class.
+ * @example
+ * const UserModel = model(withSchema(UserSchema));
+ * type User = InferModel<typeof UserModel>;
+ */
+type InferModel<T extends Type<any>> = InstanceType<T>;
+type MethodsDictionary = Record<string, Function>;
+type InnerModel<Schema extends StandardSchemaV1 = StandardSchemaV1, Props extends object = object, Methods extends MethodsDictionary = MethodsDictionary, Metadata extends ModelMetadata | undefined = ModelMetadata | undefined> = {
+  schema: Schema;
+  props: Props;
+  methods: Methods;
+  _metadata?: Metadata;
+};
+type ModelFeatureResult = {
+  schema: StandardSchemaV1;
+  props: object;
+  methods: MethodsDictionary;
+  _metadata?: ModelMetadata;
+};
+type ModelFeature<Input extends ModelFeatureResult = ModelFeatureResult, Output extends ModelFeatureResult = ModelFeatureResult> = (store: InnerModel<Input['schema'], Input['props'], Input['methods'], Input['_metadata']>) => InnerModel<Output['schema'], Output['props'], Output['methods'], Output['_metadata']>;
+type EmptyFeatureResult = ModelFeatureResult & {
+  props: {};
+  methods: {};
+};
+/**
+ * Interface for model instances with validation methods.
+ */
+interface ModelInstance<T = unknown> {
+  /**
+   * Validate the current model data.
+   * @returns ValidationResult with either the validated value or error
+   */
+  validate(): ValidationResult<T>;
+  /**
+   * Check if the model data is valid.
+   * @returns true if valid, false otherwise
+   */
+  isValid(): boolean;
+  /**
+   * Convert model to a plain object (for Firestore writes).
+   * Excludes methods, keeps only data properties.
+   */
+  toObject(): T;
+}
+//#endregion
+//#region src/model.d.ts
+type ModelMembers<FeatureResult extends ModelFeatureResult> = Prettify<OmitPrivate<FeatureResult['props'] & FeatureResult['methods']>>;
+declare function model<F1 extends ModelFeatureResult>(f1: ModelFeature<EmptyFeatureResult, F1>): Type<ModelMembers<F1>>;
+declare function model<F1 extends ModelFeatureResult, F2 extends ModelFeatureResult, R extends ModelFeatureResult = F1 & F2>(f1: ModelFeature<EmptyFeatureResult, F1>, f2: ModelFeature<{} & F1, F2>): Type<ModelMembers<R>>;
+declare function model<F1 extends ModelFeatureResult, F2 extends ModelFeatureResult, F3 extends ModelFeatureResult, R extends ModelFeatureResult = F1 & F2 & F3>(f1: ModelFeature<EmptyFeatureResult, F1>, f2: ModelFeature<{} & F1, F2>, f3: ModelFeature<F1 & F2, F3>): Type<ModelMembers<R>>;
+declare function model<F1 extends ModelFeatureResult, F2 extends ModelFeatureResult, F3 extends ModelFeatureResult, F4 extends ModelFeatureResult, R extends ModelFeatureResult = F1 & F2 & F3 & F4>(f1: ModelFeature<EmptyFeatureResult, F1>, f2: ModelFeature<{} & F1, F2>, f3: ModelFeature<F1 & F2, F3>, f4: ModelFeature<F1 & F2 & F3, F4>): Type<ModelMembers<R>>;
+declare function model<F1 extends ModelFeatureResult, F2 extends ModelFeatureResult, F3 extends ModelFeatureResult, F4 extends ModelFeatureResult, F5 extends ModelFeatureResult, R extends ModelFeatureResult = F1 & F2 & F3 & F4 & F5>(f1: ModelFeature<EmptyFeatureResult, F1>, f2: ModelFeature<{} & F1, F2>, f3: ModelFeature<F1 & F2, F3>, f4: ModelFeature<F1 & F2 & F3, F4>, f5: ModelFeature<F1 & F2 & F3 & F4, F5>): Type<ModelMembers<R>>;
+declare function model<F1 extends ModelFeatureResult, F2 extends ModelFeatureResult, F3 extends ModelFeatureResult, F4 extends ModelFeatureResult, F5 extends ModelFeatureResult, F6 extends ModelFeatureResult, R extends ModelFeatureResult = F1 & F2 & F3 & F4 & F5 & F6>(f1: ModelFeature<EmptyFeatureResult, F1>, f2: ModelFeature<{} & F1, F2>, f3: ModelFeature<F1 & F2, F3>, f4: ModelFeature<F1 & F2 & F3, F4>, f5: ModelFeature<F1 & F2 & F3 & F4, F5>, f6: ModelFeature<F1 & F2 & F3 & F4 & F5, F6>): Type<ModelMembers<R>>;
+declare function model<F1 extends ModelFeatureResult, F2 extends ModelFeatureResult, F3 extends ModelFeatureResult, F4 extends ModelFeatureResult, F5 extends ModelFeatureResult, F6 extends ModelFeatureResult, F7 extends ModelFeatureResult, R extends ModelFeatureResult = F1 & F2 & F3 & F4 & F5 & F6 & F7>(f1: ModelFeature<EmptyFeatureResult, F1>, f2: ModelFeature<{} & F1, F2>, f3: ModelFeature<F1 & F2, F3>, f4: ModelFeature<F1 & F2 & F3, F4>, f5: ModelFeature<F1 & F2 & F3 & F4, F5>, f6: ModelFeature<F1 & F2 & F3 & F4 & F5, F6>, f7: ModelFeature<F1 & F2 & F3 & F4 & F5 & F6, F7>): Type<ModelMembers<R>>;
+declare function model<F1 extends ModelFeatureResult, F2 extends ModelFeatureResult, F3 extends ModelFeatureResult, F4 extends ModelFeatureResult, F5 extends ModelFeatureResult, F6 extends ModelFeatureResult, F7 extends ModelFeatureResult, F8 extends ModelFeatureResult, R extends ModelFeatureResult = F1 & F2 & F3 & F4 & F5 & F6 & F7 & F8>(f1: ModelFeature<EmptyFeatureResult, F1>, f2: ModelFeature<{} & F1, F2>, f3: ModelFeature<F1 & F2, F3>, f4: ModelFeature<F1 & F2 & F3, F4>, f5: ModelFeature<F1 & F2 & F3 & F4, F5>, f6: ModelFeature<F1 & F2 & F3 & F4 & F5, F6>, f7: ModelFeature<F1 & F2 & F3 & F4 & F5 & F6, F7>, f8: ModelFeature<F1 & F2 & F3 & F4 & F5 & F6 & F7, F8>): Type<ModelMembers<R>>;
+declare function model<F1 extends ModelFeatureResult, F2 extends ModelFeatureResult, F3 extends ModelFeatureResult, F4 extends ModelFeatureResult, F5 extends ModelFeatureResult, F6 extends ModelFeatureResult, F7 extends ModelFeatureResult, F8 extends ModelFeatureResult, F9 extends ModelFeatureResult, R extends ModelFeatureResult = F1 & F2 & F3 & F4 & F5 & F6 & F7 & F8 & F9>(f1: ModelFeature<EmptyFeatureResult, F1>, f2: ModelFeature<{} & F1, F2>, f3: ModelFeature<F1 & F2, F3>, f4: ModelFeature<F1 & F2 & F3, F4>, f5: ModelFeature<F1 & F2 & F3 & F4, F5>, f6: ModelFeature<F1 & F2 & F3 & F4 & F5, F6>, f7: ModelFeature<F1 & F2 & F3 & F4 & F5 & F6, F7>, f8: ModelFeature<F1 & F2 & F3 & F4 & F5 & F6 & F7, F8>, f9: ModelFeature<F1 & F2 & F3 & F4 & F5 & F6 & F7 & F8, F9>): Type<ModelMembers<R>>;
+//#endregion
+//#region src/model.with-schema.d.ts
+declare function withSchema<S extends StandardSchemaV1>(schema: S): ModelFeature<EmptyFeatureResult, {
+  schema: S;
+  props: StandardSchemaV1.InferOutput<S> & object;
+  methods: {};
+}>;
+//#endregion
+//#region src/model.with-timestamps.d.ts
+/**
+ * Firestore Timestamp interface - matches both firebase/firestore and firebase-admin/firestore.
+ * This allows strict typing without coupling to a specific Firebase SDK.
+ */
+interface FirestoreTimestamp {
+  readonly seconds: number;
+  readonly nanoseconds: number;
+  toDate(): Date;
+  toMillis(): number;
+}
+/**
+ * Possible values for a timestamp field on a model instance:
+ * - `Date` - after conversion from Firestore
+ * - `FirestoreTimestamp` - raw Firestore Timestamp before conversion
+ * - `undefined` - if not yet set
+ */
+type TimestampValue = Date | FirestoreTimestamp | undefined;
+/**
+ * Timestamp props type - added to model by withTimestamps.
+ */
+type TimestampProps<CreatedField extends string | false = 'createdAt', UpdatedField extends string | false = 'updatedAt'> = (CreatedField extends string ? { [K in CreatedField]?: TimestampValue } : object) & (UpdatedField extends string ? { [K in UpdatedField]?: TimestampValue } : object);
+/**
+ * Output type for withTimestamps feature - includes metadata
+ */
+type WithTimestampsOutput<Input extends ModelFeatureResult> = {
+  schema: Input['schema'];
+  props: Input['props'] & TimestampProps;
+  methods: Input['methods'];
+  _metadata: ModelMetadata;
+};
+/**
+ * Add automatic timestamp management to a model.
+ *
+ * This feature registers hooks that:
+ * - Set `createdAt` on save (if not already set)
+ * - Set `updatedAt` on save and update
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with defaults (createdAt, updatedAt)
+ * const UserModel = model(
+ *   withSchema(UserSchema),
+ *   withTimestamps(),
+ * );
+ *
+ * // Custom field names
+ * const PostModel = model(
+ *   withSchema(PostSchema),
+ *   withTimestamps({ createdAt: 'publishedAt', updatedAt: 'modifiedAt' }),
+ * );
+ *
+ * // Disable one field
+ * const LogModel = model(
+ *   withSchema(LogSchema),
+ *   withTimestamps({ updatedAt: false }), // Only track creation
+ * );
+ *
+ * // Use client-side timestamps (for offline support)
+ * const OfflineModel = model(
+ *   withSchema(OfflineSchema),
+ *   withTimestamps({ useServerTimestamp: false }),
+ * );
+ * ```
+ *
+ * @param options - Optional configuration for field names and behavior
+ */
+declare function withTimestamps<Input extends ModelFeatureResult>(options?: TimestampsOptions): ModelFeature<Input, WithTimestampsOutput<Input>>;
+//#endregion
+//#region src/repository.types.d.ts
+type RepositoryMethodsDictionary = Record<string, Function>;
+type InnerRepository<Model = unknown, Path extends string = string, Methods extends RepositoryMethodsDictionary = RepositoryMethodsDictionary> = {
+  model: Type<Model>;
+  path: Path;
+  methods: Methods;
+  getCollection(params: ExtractPathParams<Path>): CollectionReference<Model>;
+  getDocument(params: ExtractPathParams<Path>, id: string): DocumentReference<Model>;
+};
+type RepositoryFeatureResult<Model = unknown, Path extends string = string, Methods extends RepositoryMethodsDictionary = RepositoryMethodsDictionary> = {
+  model: Type<Model>;
+  path: Path;
+  methods: Methods;
+};
+type RepositoryFeature<Input extends RepositoryFeatureResult = RepositoryFeatureResult, Output extends RepositoryFeatureResult = RepositoryFeatureResult> = (repo: InnerRepository<Input['model'], Input['path'], Input['methods']>) => Output['methods'];
+type RepositoryConfig<Model, Path extends string> = {
+  path: Path;
+  model: Type<Model>;
+};
+/**
+ * Base repository methods available on all repositories.
+ *
+ * Transaction/batch context is automatically detected from AsyncContext -
+ * no need to pass context explicitly.
+ */
+type BaseRepositoryMethods<Model, Path extends string> = {
+  /**
+   * Get a single document by ID.
+   * Automatically uses transaction context if called within runTransaction().
+   *
+   * @param params - Path parameters for nested collections
+   * @param id - Document ID
+   */
+  get(params: ExtractPathParams<Path>, id: string): Promise<Model | null>;
+  /**
+   * Find documents matching a query.
+   * Automatically uses transaction context if called within runTransaction().
+   *
+   * @param params - Path parameters for nested collections
+   * @param queryFn - Optional query builder function
+   */
+  find(params: ExtractPathParams<Path>, queryFn?: QueryFn<Model>): Promise<Model[]>;
+  /**
+   * Save a model (create or overwrite entire document).
+   * Automatically uses transaction/batch context if called within runTransaction() or writeBatch().
+   *
+   * @param params - Path parameters for nested collections
+   * @param model - Model instance to save
+   */
+  save(params: ExtractPathParams<Path>, model: Model): Promise<void>;
+  /**
+   * Update specific fields using Firestore dot-notation.
+   * Automatically uses transaction/batch context if called within runTransaction() or writeBatch().
+   *
+   * @param params - Path parameters for nested collections
+   * @param modelOrId - Model instance or document ID
+   * @param updates - Fields to update (supports dot-notation)
+   */
+  update(params: ExtractPathParams<Path>, modelOrId: Model | string, updates: FirestoreUpdate<Model>): Promise<void>;
+  /**
+   * Delete a document.
+   * Automatically uses transaction/batch context if called within runTransaction() or writeBatch().
+   *
+   * @param params - Path parameters for nested collections
+   * @param modelOrId - Model instance or document ID
+   */
+  delete(params: ExtractPathParams<Path>, modelOrId: Model | string): Promise<void>;
+};
+/**
+ * Primitive types that should not be recursed into
+ */
+type Primitive = string | number | boolean | bigint | symbol | null | undefined | Date;
+/**
+ * Generate all valid dot-notation paths from a type.
+ * Handles nested objects and optional properties.
+ *
+ * @example
+ * type User = { name: string; address?: { city: string; zip: number } };
+ * type Paths = DotPaths<User>; // 'name' | 'address' | 'address.city' | 'address.zip'
+ */
+type DotPaths<T, Prefix extends string = ''> = T extends Primitive ? never : T extends any[] ? Prefix extends '' ? never : never : T extends object ? { [K in keyof T & string]: `${Prefix}${K}` | (NonNullable<T[K]> extends Primitive ? never : NonNullable<T[K]> extends any[] ? never : DotPaths<NonNullable<T[K]>, `${Prefix}${K}.`>) }[keyof T & string] : never;
+/**
+ * Get the value type at a specific dot-notation path.
+ *
+ * @example
+ * type User = { address: { zip: number } };
+ * type ZipType = PathValue<User, 'address.zip'>; // number
+ */
+type PathValue<T, P$1 extends string> = P$1 extends `${infer K}.${infer Rest}` ? K extends keyof T ? PathValue<NonNullable<T[K]>, Rest> : never : P$1 extends keyof T ? T[P$1] : never;
+/**
+ * Firestore-style update object where keys are dot-notation paths
+ * and values are type-checked against the path's type.
+ *
+ * @example
+ * type User = { name: string; address: { zip: number } };
+ * const update: FirestoreUpdate<User> = {
+ *   name: 'Bob',           // ✓ valid
+ *   'address.zip': 12345,  // ✓ valid
+ *   'address.zip': 'bad',  // ✗ type error
+ * };
+ */
+type FirestoreUpdate<T> = { [P in DotPaths<T>]?: PathValue<T, P> };
+/**
+ * Extract path parameters from a Firestore path string.
+ *
+ * @example
+ * type Params = ExtractPathParams<'organizations/{organization}/users/{user}'>;
+ * // { organization: string; user: string }
+ */
+type ExtractPathParams<T extends string> = string extends T ? Record<string, string> : T extends `${string}{${infer Param}}${infer Rest}` ? { [K in Param]: string } & ExtractPathParams<Rest> : {};
+/**
+ * Check if path params are required (not an empty object)
+ */
+type HasPathParams<T extends string> = keyof ExtractPathParams<T> extends never ? false : true;
+/**
+ * Type-safe query builder interface.
+ * Wraps Firestore query methods with typed field names.
+ */
+interface TypedQueryBuilder<T> {
+  where<K$1 extends DotPaths<T>>(field: K$1, op: WhereFilterOp, value: PathValue<T, K$1>): TypedQueryBuilder<T>;
+  orderBy(field: DotPaths<T>, direction?: OrderByDirection): TypedQueryBuilder<T>;
+  limit(count: number): TypedQueryBuilder<T>;
+  startAt(...values: unknown[]): TypedQueryBuilder<T>;
+  startAfter(...values: unknown[]): TypedQueryBuilder<T>;
+  endAt(...values: unknown[]): TypedQueryBuilder<T>;
+  endBefore(...values: unknown[]): TypedQueryBuilder<T>;
+}
+/**
+ * Query function type for find() method
+ */
+type QueryFn<T> = (query: TypedQueryBuilder<T>) => TypedQueryBuilder<T>;
+//#endregion
+//#region src/repository.d.ts
+declare function repository<Model, Path extends string>(config: RepositoryConfig<Model, Path>): Type<BaseRepositoryMethods<Model, Path>>;
+declare function repository<Model, Path extends string, F1Methods extends RepositoryMethodsDictionary>(config: RepositoryConfig<Model, Path>, f1: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F1Methods>>): Type<Prettify<BaseRepositoryMethods<Model, Path> & F1Methods>>;
+declare function repository<Model, Path extends string, F1Methods extends RepositoryMethodsDictionary, F2Methods extends RepositoryMethodsDictionary>(config: RepositoryConfig<Model, Path>, f1: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F1Methods>>, f2: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F2Methods>>): Type<Prettify<BaseRepositoryMethods<Model, Path> & F1Methods & F2Methods>>;
+declare function repository<Model, Path extends string, F1Methods extends RepositoryMethodsDictionary, F2Methods extends RepositoryMethodsDictionary, F3Methods extends RepositoryMethodsDictionary>(config: RepositoryConfig<Model, Path>, f1: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F1Methods>>, f2: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F2Methods>>, f3: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F3Methods>>): Type<Prettify<BaseRepositoryMethods<Model, Path> & F1Methods & F2Methods & F3Methods>>;
+declare function repository<Model, Path extends string, F1Methods extends RepositoryMethodsDictionary, F2Methods extends RepositoryMethodsDictionary, F3Methods extends RepositoryMethodsDictionary, F4Methods extends RepositoryMethodsDictionary>(config: RepositoryConfig<Model, Path>, f1: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F1Methods>>, f2: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F2Methods>>, f3: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F3Methods>>, f4: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F4Methods>>): Type<Prettify<BaseRepositoryMethods<Model, Path> & F1Methods & F2Methods & F3Methods & F4Methods>>;
+declare function repository<Model, Path extends string, F1Methods extends RepositoryMethodsDictionary, F2Methods extends RepositoryMethodsDictionary, F3Methods extends RepositoryMethodsDictionary, F4Methods extends RepositoryMethodsDictionary, F5Methods extends RepositoryMethodsDictionary>(config: RepositoryConfig<Model, Path>, f1: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F1Methods>>, f2: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F2Methods>>, f3: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F3Methods>>, f4: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F4Methods>>, f5: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F5Methods>>): Type<Prettify<BaseRepositoryMethods<Model, Path> & F1Methods & F2Methods & F3Methods & F4Methods & F5Methods>>;
+declare function repository<Model, Path extends string, F1Methods extends RepositoryMethodsDictionary, F2Methods extends RepositoryMethodsDictionary, F3Methods extends RepositoryMethodsDictionary, F4Methods extends RepositoryMethodsDictionary, F5Methods extends RepositoryMethodsDictionary, F6Methods extends RepositoryMethodsDictionary>(config: RepositoryConfig<Model, Path>, f1: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F1Methods>>, f2: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F2Methods>>, f3: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F3Methods>>, f4: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F4Methods>>, f5: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F5Methods>>, f6: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F6Methods>>): Type<Prettify<BaseRepositoryMethods<Model, Path> & F1Methods & F2Methods & F3Methods & F4Methods & F5Methods & F6Methods>>;
+declare function repository<Model, Path extends string, F1Methods extends RepositoryMethodsDictionary, F2Methods extends RepositoryMethodsDictionary, F3Methods extends RepositoryMethodsDictionary, F4Methods extends RepositoryMethodsDictionary, F5Methods extends RepositoryMethodsDictionary, F6Methods extends RepositoryMethodsDictionary, F7Methods extends RepositoryMethodsDictionary>(config: RepositoryConfig<Model, Path>, f1: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F1Methods>>, f2: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F2Methods>>, f3: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F3Methods>>, f4: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F4Methods>>, f5: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F5Methods>>, f6: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F6Methods>>, f7: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F7Methods>>): Type<Prettify<BaseRepositoryMethods<Model, Path> & F1Methods & F2Methods & F3Methods & F4Methods & F5Methods & F6Methods & F7Methods>>;
+declare function repository<Model, Path extends string, F1Methods extends RepositoryMethodsDictionary, F2Methods extends RepositoryMethodsDictionary, F3Methods extends RepositoryMethodsDictionary, F4Methods extends RepositoryMethodsDictionary, F5Methods extends RepositoryMethodsDictionary, F6Methods extends RepositoryMethodsDictionary, F7Methods extends RepositoryMethodsDictionary, F8Methods extends RepositoryMethodsDictionary>(config: RepositoryConfig<Model, Path>, f1: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F1Methods>>, f2: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F2Methods>>, f3: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F3Methods>>, f4: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F4Methods>>, f5: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F5Methods>>, f6: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F6Methods>>, f7: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F7Methods>>, f8: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F8Methods>>): Type<Prettify<BaseRepositoryMethods<Model, Path> & F1Methods & F2Methods & F3Methods & F4Methods & F5Methods & F6Methods & F7Methods & F8Methods>>;
+declare function repository<Model, Path extends string, F1Methods extends RepositoryMethodsDictionary, F2Methods extends RepositoryMethodsDictionary, F3Methods extends RepositoryMethodsDictionary, F4Methods extends RepositoryMethodsDictionary, F5Methods extends RepositoryMethodsDictionary, F6Methods extends RepositoryMethodsDictionary, F7Methods extends RepositoryMethodsDictionary, F8Methods extends RepositoryMethodsDictionary, F9Methods extends RepositoryMethodsDictionary>(config: RepositoryConfig<Model, Path>, f1: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F1Methods>>, f2: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F2Methods>>, f3: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F3Methods>>, f4: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F4Methods>>, f5: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F5Methods>>, f6: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F6Methods>>, f7: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F7Methods>>, f8: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F8Methods>>, f9: RepositoryFeature<RepositoryFeatureResult<Model, Path>, RepositoryFeatureResult<Model, Path, F9Methods>>): Type<Prettify<BaseRepositoryMethods<Model, Path> & F1Methods & F2Methods & F3Methods & F4Methods & F5Methods & F6Methods & F7Methods & F8Methods & F9Methods>>;
+//#endregion
+//#region src/repository.with-methods.d.ts
+/**
+ * Add custom methods to a repository
+ */
+declare function withMethods<Model, Path extends string, BaseMethods extends RepositoryMethodsDictionary, NewMethods extends RepositoryMethodsDictionary>(methodsFactory: (repo: InnerRepository<Model, Path, BaseMethods>) => NewMethods): RepositoryFeature<RepositoryFeatureResult<Model, Path, BaseMethods>, RepositoryFeatureResult<Model, Path, BaseMethods & NewMethods>>;
+//#endregion
+//#region src/transaction.d.ts
+/**
+ * Run operations within a Firestore transaction.
+ *
+ * Transactions provide:
+ * - Atomic reads and writes across multiple repositories
+ * - Automatic retry on contention (up to maxAttempts)
+ * - Consistent view of data (all reads see same snapshot)
+ * - All-or-nothing semantics (all writes succeed or all fail)
+ *
+ * The transaction context is **automatically propagated** to all repository
+ * methods called within the transaction function - no need to pass context explicitly.
+ *
+ * @example
+ * ```typescript
+ * // Transfer funds between accounts atomically
+ * const result = await runTransaction(async () => {
+ *   const fromAccount = await AccountRepo.get({}, fromId);
+ *   const toAccount = await AccountRepo.get({}, toId);
+ *
+ *   if (!fromAccount || !toAccount) throw new Error('Account not found');
+ *   if (fromAccount.balance < amount) throw new Error('Insufficient funds');
+ *
+ *   await AccountRepo.update({}, fromId, {
+ *     balance: fromAccount.balance - amount
+ *   });
+ *
+ *   await AccountRepo.update({}, toId, {
+ *     balance: toAccount.balance + amount
+ *   });
+ *
+ *   return { newBalance: fromAccount.balance - amount };
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Cross-repository transaction
+ * await runTransaction(async () => {
+ *   const order = await OrderRepo.get({}, orderId);
+ *   const user = await UserRepo.get({}, order.userId);
+ *
+ *   await OrderRepo.update({}, orderId, { status: 'paid' });
+ *   await UserRepo.update({}, user.id, {
+ *     balance: user.balance - order.total
+ *   });
+ * });
+ * ```
+ *
+ * @param fn - Async function to run within the transaction
+ * @param options - Transaction options (maxAttempts, etc.)
+ * @returns Result of the transaction function
+ */
+declare function runTransaction<T>(fn: () => Promise<T>, options?: TransactionOptions): Promise<T>;
+//#endregion
+export { AdapterNotInitializedError, AuditConfig, AuditOptions, BaseRepositoryMethods, BatchContext, CollectionReference, DEFAULT_AUDIT, DEFAULT_STATUS, DEFAULT_TIMESTAMPS, DocumentReference, DocumentSnapshot, DotPaths, EmptyFeatureResult, ExtractPathParams, FeatureHooks, FirestoreAdapter, FirestoreError, FirestoreTimestamp, FirestoreUpdate, FyreStackError, HasPathParams, InferModel, InnerModel, InnerRepository, MAX_BATCH_SIZE, MODEL_METADATA, MODEL_SCHEMA, MethodsDictionary, ModelError, ModelFeature, ModelFeatureResult, ModelHookContext, ModelHooks, ModelInstance, ModelMetadata, NotFoundError, OperationContext, OrderByDirection, PathParamError, PathValue, QueryFn, QueryReference, QuerySnapshot, RepositoryConfig, RepositoryFeature, RepositoryFeatureResult, RepositoryHookContext, RepositoryHooks, RepositoryMethodsDictionary, ServerTimestampSentinel, StatusConfig, StatusOptions, TimestampProps, TimestampValue, TimestampsConfig, TimestampsOptions, Transaction, TransactionContext, TransactionOptions, TypedQueryBuilder, ValidationError, ValidationIssue, ValidationResult, WhereFilterOp, WriteBatch, _resetFirestoreAdapter, createFeatureMetadata, getAuditConfig, getCurrentBatch, getCurrentContext, getCurrentTransaction, getFeatureConfig, getFirestoreAdapter, getModelHooks, getModelMetadata, getRepositoryHooks, getStatusConfig, getTimestampsConfig, hasAudit, hasFeature, hasRepositoryHooks, hasStatus, hasTimestamps, isBatchContext, isInBatch, isInTransaction, isServerTimestamp, isTransactionContext, isValidResult, mergeFeatureHooks, mergeModelHooks, mergeRepositoryHooks, model, repository, runTransaction, runWithBatch, runWithTransaction, setFirestoreAdapter, withMethods, withSchema, withTimestamps, writeBatch, writeChunkedBatch };
+//# sourceMappingURL=index.d.cts.map