import { type Maybe } from '@dereekb/util';
import { type CollectionReference, type FirestoreCollection, type FirestoreContext, AbstractFirestoreDocument, type SingleItemFirestoreCollection, type FirestoreCollectionWithParent, AbstractFirestoreDocumentWithParent, type ExpectedFirestoreModelData, type FirestoreModelData, type CollectionGroup, type FirestoreCollectionGroup, type UserRelated, type UserRelatedById, type SystemStateStoredData, type SystemStateStoredDataConverterMap, type SystemStateStoredDataFieldConverterConfig, type PagedItemConverter, type PagedItemDistributionScheme, type PagedItemFirestoreCollection, type PagedItemPageData } from '@dereekb/firebase';
import { type GrantedReadRole } from '@dereekb/model';
/**
 * Union of all mock model identity types used in the test suite.
 *
 * Each member corresponds to one of the mock Firestore models defined in this file.
 * Useful for generic constraints that need to accept any mock model identity.
 */
export type MockItemTypes = typeof mockItemIdentity | typeof mockItemPrivateIdentity | typeof mockItemUserIdentity | typeof mockItemSubItemIdentity | typeof mockItemSubItemDeepIdentity | typeof mockItemPagedIdentity;
/**
 * {@link firestoreModelIdentity} for the root-level mock item collection (`mockItem` / `mi`).
 */
export declare const mockItemIdentity: import("@dereekb/firebase").RootFirestoreModelIdentity<"mockItem", "mi">;
/**
 * Application-level data for the root mock Firestore model.
 *
 * This is the converted (in-memory) representation. For the raw database representation,
 * see {@link MockItemData}.
 */
export interface MockItem {
    value?: Maybe<string>;
    /**
     * Optional date value
     */
    date?: Maybe<Date>;
    /**
     * Optional number value
     */
    number?: Maybe<number>;
    /**
     * List of tags.
     */
    tags?: Maybe<string[]>;
    /**
     * The test value is alway present.
     */
    test: boolean;
}
/**
 * Possible granted roles for {@link MockItem}. Includes the standard read role plus an admin role.
 */
export type MockItemRoles = GrantedReadRole | 'admin';
/**
 * {@link AbstractFirestoreDocument} implementation for {@link MockItem}.
 *
 * Provides document-level access to a single MockItem in Firestore.
 */
export declare class MockItemDocument extends AbstractFirestoreDocument<MockItem, MockItemDocument, typeof mockItemIdentity> {
    get modelIdentity(): import("@dereekb/firebase").RootFirestoreModelIdentity<"mockItem", "mi">;
}
/**
 * MockItem as it is stored into the database.
 *
 * Test is optional.
 */
export type MockItemData = FirestoreModelData<MockItem, {
    /**
     * The test value may not be defined in the database.
     */
    test?: Maybe<boolean>;
}>;
/**
 * Used to build a FirestoreDataConverter. Fields are configured via configuration. See the SnapshotConverterFunctions for more info.
 */
export declare const mockItemConverter: import("@dereekb/firebase").SnapshotConverterFunctions<MockItem, Partial<import("@dereekb/util").ReplaceType<MockItem, import("@dereekb/util").MaybeMap<{
    /**
     * The test value may not be defined in the database.
     */
    test?: Maybe<boolean>;
}>, any>>>;
/**
 * Used to build a mockItemCollection from a firestore instance with a converter setup.
 *
 * @param context - The Firestore context to resolve the root collection against.
 * @returns A typed {@link CollectionReference} for the root MockItem collection.
 */
export declare function mockItemCollectionReference(context: FirestoreContext): CollectionReference<MockItem>;
/**
 * Typed {@link FirestoreCollection} for {@link MockItem} documents.
 */
export type MockItemFirestoreCollection = FirestoreCollection<MockItem, MockItemDocument>;
/**
 * Creates a {@link MockItemFirestoreCollection} bound to the given {@link FirestoreContext}.
 *
 * @param firestoreContext - The Firestore context (test or production) used to resolve the underlying collection reference.
 * @returns A {@link MockItemFirestoreCollection} wired with the {@link mockItemConverter} and {@link mockItemIdentity}.
 *
 * @example
 * ```ts
 * const collection = mockItemFirestoreCollection(firestoreContext);
 * const doc = collection.documentAccessor().newDocument();
 * ```
 */
export declare function mockItemFirestoreCollection(firestoreContext: FirestoreContext): MockItemFirestoreCollection;
/**
 * {@link firestoreModelIdentity} for the MockItemPrivate subcollection (`mockItemPrivate` / `mip`).
 *
 * This is a child identity of {@link mockItemIdentity}, meaning MockItemPrivate documents
 * live as subcollections under MockItem documents.
 */
export declare const mockItemPrivateIdentity: import("@dereekb/firebase").FirestoreModelIdentityWithParent<import("@dereekb/firebase").RootFirestoreModelIdentity<"mockItem", "mi">, "mockItemPrivate", "mip">;
/**
 * Bitwise-encoded settings object representing cardinal directions.
 *
 * Used in conjunction with {@link mockItemSettingsItemDencoder} to test
 * {@link firestoreBitwiseObjectMap} encoding/decoding in Firestore.
 */
export interface MockItemSettingsItem {
    north?: boolean;
    south?: boolean;
    east?: boolean;
    west?: boolean;
}
/**
 * Enum indices for {@link MockItemSettingsItem} cardinal directions, used by the bitwise dencoder.
 */
export declare enum MockItemSettingsItemEnum {
    NORTH = 0,
    SOUTH = 1,
    EAST = 2,
    WEST = 3
}
/**
 * Bitwise dencoder (encoder/decoder) for {@link MockItemSettingsItem}.
 *
 * Converts between a boolean-keyed object and a compact bitwise integer
 * representation for efficient Firestore storage.
 */
export declare const mockItemSettingsItemDencoder: import("@dereekb/util").BitwiseObjectDencoder<MockItemSettingsItem>;
/**
 * Map of string keys to {@link MockItemSettingsItem} values.
 *
 * Stored in Firestore using {@link firestoreBitwiseObjectMap}, where each entry
 * is encoded as a compact bitwise integer.
 */
export type MockItemSettingsMap = Record<string, MockItemSettingsItem>;
/**
 * Private data for each MockItem.
 *
 * There is only a single private data item per each MockItem.
 */
export interface MockItemPrivate {
    comments?: Maybe<string>;
    num: number;
    values: string[];
    settings: MockItemSettingsMap;
    createdAt: Date;
}
/**
 * Possible granted roles for {@link MockItemPrivate}.
 */
export type MockItemPrivateRoles = GrantedReadRole | 'admin';
/**
 * {@link AbstractFirestoreDocument} implementation for {@link MockItemPrivate}.
 */
export declare class MockItemPrivateDocument extends AbstractFirestoreDocument<MockItemPrivate, MockItemPrivateDocument, typeof mockItemPrivateIdentity> {
    get modelIdentity(): import("@dereekb/firebase").FirestoreModelIdentityWithParent<import("@dereekb/firebase").RootFirestoreModelIdentity<"mockItem", "mi">, "mockItemPrivate", "mip">;
}
/**
 * Raw Firestore storage type for {@link MockItemPrivate}.
 */
export type MockItemPrivateData = FirestoreModelData<MockItemPrivate, {}>;
/**
 * Used to build a FirestoreDataConverter. Fields are configured via configuration. See the SnapshotConverterFunctions for more info.
 */
export declare const mockItemPrivateConverter: import("@dereekb/firebase").SnapshotConverterFunctions<{
    comments?: Maybe<string>;
    num: number;
    values: string[];
    settings: MockItemSettingsMap;
    createdAt: Date;
}, Partial<import("@dereekb/util").ReplaceType<{
    comments?: Maybe<string>;
    num: number;
    values: string[];
    settings: MockItemSettingsMap;
    createdAt: Date;
}, import("@dereekb/util").MaybeMap<object>, any>>>;
/**
 * Creates a factory that produces {@link CollectionReference} instances for {@link MockItemPrivate}
 * subcollections under a given {@link MockItemDocument} parent.
 *
 * @param context - The Firestore context used to resolve subcollections.
 * @returns Function that, given a parent {@link MockItemDocument}, returns a typed {@link CollectionReference} for that parent's MockItemPrivate subcollection.
 */
export declare function mockItemPrivateCollectionReferenceFactory(context: FirestoreContext): (parent: MockItemDocument) => CollectionReference<MockItemPrivate>;
/**
 * Typed {@link SingleItemFirestoreCollection} for {@link MockItemPrivate}, constrained to one document per parent.
 */
export type MockItemPrivateFirestoreCollection = SingleItemFirestoreCollection<MockItemPrivate, MockItem, MockItemPrivateDocument>;
/**
 * Factory function type that creates a {@link MockItemPrivateFirestoreCollection} for a given parent.
 */
export type MockItemPrivateFirestoreCollectionFactory = (parent: MockItemDocument) => MockItemPrivateFirestoreCollection;
/**
 * Creates a factory for producing {@link MockItemPrivateFirestoreCollection} instances bound to a parent {@link MockItemDocument}.
 *
 * @param firestoreContext - The Firestore context used to resolve the underlying subcollection.
 * @returns A factory that, given a parent {@link MockItemDocument}, returns a single-item collection wired with {@link mockItemPrivateConverter}.
 */
export declare function mockItemPrivateFirestoreCollection(firestoreContext: FirestoreContext): MockItemPrivateFirestoreCollectionFactory;
/**
 * Creates a {@link CollectionGroup} reference for querying all {@link MockItemPrivate} documents across parents.
 *
 * @param context - The Firestore context used to resolve the collection group.
 * @returns A typed {@link CollectionGroup} reference for the MockItemPrivate collection name.
 */
export declare function mockItemPrivateCollectionReference(context: FirestoreContext): CollectionGroup<MockItemPrivate>;
/**
 * Typed {@link FirestoreCollectionGroup} for querying {@link MockItemPrivate} across all parent documents.
 */
export type MockItemPrivateFirestoreCollectionGroup = FirestoreCollectionGroup<MockItemPrivate, MockItemPrivateDocument>;
/**
 * Creates a {@link MockItemPrivateFirestoreCollectionGroup} for cross-parent queries on {@link MockItemPrivate}.
 *
 * @param firestoreContext - The Firestore context used to resolve the underlying collection group reference.
 * @returns A typed {@link MockItemPrivateFirestoreCollectionGroup} wired with the {@link mockItemPrivateConverter}.
 */
export declare function mockItemPrivateFirestoreCollectionGroup(firestoreContext: FirestoreContext): MockItemPrivateFirestoreCollectionGroup;
/**
 * {@link firestoreModelIdentity} for the MockItemUser subcollection (`mockItemUser` / `miu`).
 *
 * Child of {@link mockItemIdentity}. Represents per-user data associated with a {@link MockItem}.
 */
export declare const mockItemUserIdentity: import("@dereekb/firebase").FirestoreModelIdentityWithParent<import("@dereekb/firebase").RootFirestoreModelIdentity<"mockItem", "mi">, "mockItemUser", "miu">;
/**
 * An item associated per user to this item.
 */
export interface MockItemUser extends UserRelated, UserRelatedById {
    name: string;
}
/**
 * Possible granted roles for {@link MockItemUser}.
 */
export type MockItemUserRoles = GrantedReadRole | 'admin';
/**
 * {@link AbstractFirestoreDocument} implementation for {@link MockItemUser}.
 */
export declare class MockItemUserDocument extends AbstractFirestoreDocument<MockItemUser, MockItemUserDocument, typeof mockItemUserIdentity> {
    get modelIdentity(): import("@dereekb/firebase").FirestoreModelIdentityWithParent<import("@dereekb/firebase").RootFirestoreModelIdentity<"mockItem", "mi">, "mockItemUser", "miu">;
}
/**
 * Raw Firestore storage type for {@link MockItemUser}.
 */
export type MockItemUserData = FirestoreModelData<MockItemUser, {}>;
/**
 * Firestore collection path name.
 */
export declare const MOCK_ITEM_USER_COLLECTION_NAME = "mockItemUser";
/**
 * Default document identifier used for MockItemUser in tests.
 */
export declare const MOCK_ITEM_USER_IDENTIFIER = "0";
/**
 * Used to build a FirestoreDataConverter. Fields are configured via configuration. See the SnapshotConverterFunctions for more info.
 */
export declare const mockItemUserConverter: import("@dereekb/firebase").SnapshotConverterFunctions<{
    name: string;
    uid: import("@dereekb/firebase").FirebaseAuthUserId;
}, Partial<import("@dereekb/util").ReplaceType<{
    name: string;
    uid: import("@dereekb/firebase").FirebaseAuthUserId;
}, import("@dereekb/util").MaybeMap<object>, any>>>;
/**
 * Creates a factory that produces {@link CollectionReference} instances for {@link MockItemUser}
 * subcollections under a given {@link MockItemDocument} parent.
 *
 * @param context - The Firestore context used to resolve subcollections.
 * @returns Function that, given a parent {@link MockItemDocument}, returns a typed {@link CollectionReference} for that parent's MockItemUser subcollection.
 */
export declare function mockItemUserCollectionReferenceFactory(context: FirestoreContext): (parent: MockItemDocument) => CollectionReference<MockItemUser>;
/**
 * Accessor factory for {@link MockItemUser} that copies user-related fields (uid) when creating documents.
 */
export declare const mockItemUserAccessorFactory: import("@dereekb/firebase").InterceptAccessorFactoryFunction<MockItemUser, import("@dereekb/firebase").DocumentData>;
/**
 * Typed {@link FirestoreCollectionWithParent} for {@link MockItemUser} documents under a {@link MockItem}.
 */
export type MockItemUserFirestoreCollection = FirestoreCollectionWithParent<MockItemUser, MockItem, MockItemUserDocument>;
/**
 * Factory function type that creates a {@link MockItemUserFirestoreCollection} for a given parent.
 */
export type MockItemUserFirestoreCollectionFactory = (parent: MockItemDocument) => MockItemUserFirestoreCollection;
/**
 * Creates a factory for producing {@link MockItemUserFirestoreCollection} instances bound to a parent {@link MockItemDocument}.
 *
 * @param firestoreContext - The Firestore context used to resolve the underlying subcollection.
 * @returns A factory that, given a parent {@link MockItemDocument}, returns a per-parent collection wired with {@link mockItemUserConverter} and {@link mockItemUserAccessorFactory}.
 */
export declare function mockItemUserFirestoreCollection(firestoreContext: FirestoreContext): MockItemUserFirestoreCollectionFactory;
/**
 * Creates a {@link CollectionGroup} reference for querying all {@link MockItemUser} documents across parents.
 *
 * @param context - The Firestore context used to resolve the collection group.
 * @returns A typed {@link CollectionGroup} reference for the MockItemUser collection name.
 */
export declare function mockItemUserCollectionReference(context: FirestoreContext): CollectionGroup<MockItemUser>;
/**
 * Typed {@link FirestoreCollectionGroup} for querying {@link MockItemUser} across all parent documents.
 */
export type MockItemUserFirestoreCollectionGroup = FirestoreCollectionGroup<MockItemUser, MockItemUserDocument>;
/**
 * Creates a {@link MockItemUserFirestoreCollectionGroup} for cross-parent queries on {@link MockItemUser}.
 *
 * @param firestoreContext - The Firestore context used to resolve the underlying collection group reference.
 * @returns A typed {@link MockItemUserFirestoreCollectionGroup} wired with the {@link mockItemUserConverter} and {@link mockItemUserAccessorFactory}.
 */
export declare function mockItemUserFirestoreCollectionGroup(firestoreContext: FirestoreContext): MockItemUserFirestoreCollectionGroup;
/**
 * {@link firestoreModelIdentity} for the MockItemSubItem subcollection (`mockItemSub` / `misi`).
 *
 * Child of {@link mockItemIdentity}. Unlike {@link MockItemPrivate} (single item) or {@link MockItemUser} (per-user),
 * there can be an unlimited number of sub-items per parent MockItem.
 */
export declare const mockItemSubItemIdentity: import("@dereekb/firebase").FirestoreModelIdentityWithParent<import("@dereekb/firebase").RootFirestoreModelIdentity<"mockItem", "mi">, "mockItemSub", "misi">;
/**
 * Data for a sub item in our firestore collection.
 *
 * There may be an unlimited number of MockItemSubItems for a MockItem.
 */
export interface MockItemSubItem {
    value?: Maybe<number>;
}
/**
 * Possible granted roles for {@link MockItemSubItem}.
 */
export type MockItemSubItemRoles = GrantedReadRole | 'admin';
/**
 * {@link AbstractFirestoreDocumentWithParent} implementation for {@link MockItemSubItem}.
 *
 * Maintains a reference to its parent {@link MockItem} document.
 */
export declare class MockItemSubItemDocument extends AbstractFirestoreDocumentWithParent<MockItem, MockItemSubItem, MockItemSubItemDocument, typeof mockItemSubItemIdentity> {
    get modelIdentity(): import("@dereekb/firebase").FirestoreModelIdentityWithParent<import("@dereekb/firebase").RootFirestoreModelIdentity<"mockItem", "mi">, "mockItemSub", "misi">;
}
/**
 * Raw Firestore storage type for {@link MockItemSubItem}. All fields match the application type exactly.
 */
export type MockItemSubItemData = ExpectedFirestoreModelData<MockItemSubItem>;
/**
 * Used to build a FirestoreDataConverter. Fields are configured via configuration. See the SnapshotConverterFunctions for more info.
 */
export declare const mockItemSubItemConverter: import("@dereekb/firebase").SnapshotConverterFunctions<MockItemSubItem, import("@dereekb/util").ReplaceType<MockItemSubItem, object, any>>;
/**
 * Creates a factory that produces {@link CollectionReference} instances for {@link MockItemSubItem}
 * subcollections under a given {@link MockItemDocument} parent.
 *
 * @param context - The Firestore context used to resolve subcollections.
 * @returns Function that, given a parent {@link MockItemDocument}, returns a typed {@link CollectionReference} for that parent's MockItemSubItem subcollection.
 */
export declare function mockItemSubItemCollectionReferenceFactory(context: FirestoreContext): (parent: MockItemDocument) => CollectionReference<MockItemSubItem>;
/**
 * Typed {@link FirestoreCollectionWithParent} for {@link MockItemSubItem} documents under a {@link MockItem}.
 */
export type MockItemSubItemFirestoreCollection = FirestoreCollectionWithParent<MockItemSubItem, MockItem, MockItemSubItemDocument, MockItemDocument>;
/**
 * Factory function type that creates a {@link MockItemSubItemFirestoreCollection} for a given parent.
 */
export type MockItemSubItemFirestoreCollectionFactory = (parent: MockItemDocument) => MockItemSubItemFirestoreCollection;
/**
 * Creates a factory for producing {@link MockItemSubItemFirestoreCollection} instances bound to a parent {@link MockItemDocument}.
 *
 * @param firestoreContext - The Firestore context used to resolve the underlying subcollection.
 * @returns A factory that, given a parent {@link MockItemDocument}, returns a per-parent collection wired with {@link mockItemSubItemConverter}.
 */
export declare function mockItemSubItemFirestoreCollection(firestoreContext: FirestoreContext): MockItemSubItemFirestoreCollectionFactory;
/**
 * Creates a {@link CollectionGroup} reference for querying all {@link MockItemSubItem} documents across parents.
 *
 * @param context - The Firestore context used to resolve the collection group.
 * @returns A typed {@link CollectionGroup} reference for the MockItemSubItem collection name.
 */
export declare function mockItemSubItemCollectionReference(context: FirestoreContext): CollectionGroup<MockItemSubItem>;
/**
 * Typed {@link FirestoreCollectionGroup} for querying {@link MockItemSubItem} across all parent documents.
 */
export type MockItemSubItemFirestoreCollectionGroup = FirestoreCollectionGroup<MockItemSubItem, MockItemSubItemDocument>;
/**
 * Creates a {@link MockItemSubItemFirestoreCollectionGroup} for cross-parent queries on {@link MockItemSubItem}.
 *
 * @param firestoreContext - The Firestore context used to resolve the underlying collection group reference.
 * @returns A typed {@link MockItemSubItemFirestoreCollectionGroup} wired with the {@link mockItemSubItemConverter}.
 */
export declare function mockItemSubItemFirestoreCollectionGroup(firestoreContext: FirestoreContext): MockItemSubItemFirestoreCollectionGroup;
/**
 * {@link firestoreModelIdentity} for the MockItemSubItemDeep subcollection (`mockItemSubItemDeep` / `misid`).
 *
 * Child of {@link mockItemSubItemIdentity}, making this a three-level-deep nested collection
 * (MockItem -> MockItemSubItem -> MockItemSubItemDeep). Useful for testing deeply nested document access patterns.
 */
export declare const mockItemSubItemDeepIdentity: import("@dereekb/firebase").FirestoreModelIdentityWithParent<import("@dereekb/firebase").FirestoreModelIdentityWithParent<import("@dereekb/firebase").RootFirestoreModelIdentity<"mockItem", "mi">, "mockItemSub", "misi">, "mockItemSubItemDeep", "misid">;
/**
 * Data for a sub item in our firestore collection.
 *
 * There may be an unlimited number of MockItemSubItemDeeps for a MockSubItem.
 */
export interface MockItemSubItemDeep {
    value?: Maybe<number>;
}
/**
 * Possible granted roles for {@link MockItemSubItemDeep}.
 */
export type MockItemSubItemDeepRoles = GrantedReadRole | 'admin';
/**
 * {@link AbstractFirestoreDocumentWithParent} implementation for {@link MockItemSubItemDeep}.
 *
 * Maintains a reference to its parent {@link MockItemSubItem} document.
 */
export declare class MockItemSubItemDeepDocument extends AbstractFirestoreDocumentWithParent<MockItemSubItem, MockItemSubItemDeep, MockItemSubItemDeepDocument, typeof mockItemSubItemDeepIdentity> {
    get modelIdentity(): import("@dereekb/firebase").FirestoreModelIdentityWithParent<import("@dereekb/firebase").FirestoreModelIdentityWithParent<import("@dereekb/firebase").RootFirestoreModelIdentity<"mockItem", "mi">, "mockItemSub", "misi">, "mockItemSubItemDeep", "misid">;
}
/**
 * Raw Firestore storage type for {@link MockItemSubItemDeep}. All fields match the application type exactly.
 */
export type MockItemSubItemDeepData = ExpectedFirestoreModelData<MockItemSubItemDeep>;
/**
 * Used to build a FirestoreDataConverter. Fields are configured via configuration. See the SnapshotConverterFunctions for more info.
 */
export declare const mockItemSubItemDeepConverter: import("@dereekb/firebase").SnapshotConverterFunctions<MockItemSubItemDeep, import("@dereekb/util").ReplaceType<MockItemSubItemDeep, object, any>>;
/**
 * Creates a factory that produces {@link CollectionReference} instances for {@link MockItemSubItemDeep}
 * subcollections under a given {@link MockItemSubItemDocument} parent.
 *
 * @param context - The Firestore context used to resolve subcollections.
 * @returns Function that, given a parent {@link MockItemSubItemDocument}, returns a typed {@link CollectionReference} for that parent's MockItemSubItemDeep subcollection.
 */
export declare function mockItemSubItemDeepCollectionReferenceFactory(context: FirestoreContext): (parent: MockItemSubItemDocument) => CollectionReference<MockItemSubItemDeep>;
/**
 * Typed {@link FirestoreCollectionWithParent} for {@link MockItemSubItemDeep} documents under a {@link MockItemSubItem}.
 */
export type MockItemSubItemDeepFirestoreCollection = FirestoreCollectionWithParent<MockItemSubItemDeep, MockItemSubItem, MockItemSubItemDeepDocument, MockItemSubItemDocument>;
/**
 * Factory function type that creates a {@link MockItemSubItemDeepFirestoreCollection} for a given parent.
 */
export type MockItemSubItemDeepFirestoreCollectionFactory = (parent: MockItemSubItemDocument) => MockItemSubItemDeepFirestoreCollection;
/**
 * Creates a factory for producing {@link MockItemSubItemDeepFirestoreCollection} instances bound to a parent {@link MockItemSubItemDocument}.
 *
 * @param firestoreContext - The Firestore context used to resolve the underlying subcollection.
 * @returns A factory that, given a parent {@link MockItemSubItemDocument}, returns a per-parent collection wired with {@link mockItemSubItemDeepConverter}.
 */
export declare function mockItemSubItemDeepFirestoreCollection(firestoreContext: FirestoreContext): MockItemSubItemDeepFirestoreCollectionFactory;
/**
 * Creates a {@link CollectionGroup} reference for querying all {@link MockItemSubItemDeep} documents across parents.
 *
 * @param context - The Firestore context used to resolve the collection group.
 * @returns A typed {@link CollectionGroup} reference for the MockItemSubItemDeep collection name.
 */
export declare function mockItemSubItemDeepCollectionReference(context: FirestoreContext): CollectionGroup<MockItemSubItemDeep>;
/**
 * Typed {@link FirestoreCollectionGroup} for querying {@link MockItemSubItemDeep} across all parent documents.
 */
export type MockItemSubItemDeepFirestoreCollectionGroup = FirestoreCollectionGroup<MockItemSubItemDeep, MockItemSubItemDeepDocument>;
/**
 * Creates a {@link MockItemSubItemDeepFirestoreCollectionGroup} for cross-parent queries on {@link MockItemSubItemDeep}.
 *
 * @param firestoreContext - The Firestore context used to resolve the underlying collection group reference.
 * @returns A typed {@link MockItemSubItemDeepFirestoreCollectionGroup} wired with the {@link mockItemSubItemDeepConverter}.
 */
export declare function mockItemSubItemDeepFirestoreCollectionGroup(firestoreContext: FirestoreContext): MockItemSubItemDeepFirestoreCollectionGroup;
/**
 * {@link firestoreModelIdentity} for the MockItemPaged subcollection (`mockItemPaged` / `mip2`).
 *
 * Child of {@link mockItemIdentity}. Stores a logical {@link MockItemPagedEntry} array distributed
 * across multiple page documents, plus an index document that summarizes the layout. See
 * {@link PagedItemFirestoreCollection} for the underlying mechanism.
 */
export declare const mockItemPagedIdentity: import("@dereekb/firebase").FirestoreModelIdentityWithParent<import("@dereekb/firebase").RootFirestoreModelIdentity<"mockItem", "mi">, "mockItemPaged", "mip2">;
/**
 * Single entry stored inside a paged subcollection page.
 *
 * Items are grouped by {@link group} when using static distribution and treated as opaque
 * payloads when using dynamic (count-based) paging.
 */
export interface MockItemPagedEntry {
    readonly id: string;
    readonly group: string;
    readonly value: number;
}
/**
 * Possible granted roles for {@link MockItemPagedEntry} pages.
 */
export type MockItemPagedRoles = GrantedReadRole | 'admin';
/**
 * Page-document model shape for {@link MockItemPagedEntry}. The paged collection stores entries
 * inside this envelope (`i` = items, `c` = count). The standalone index document
 * (`{@link DEFAULT_PAGED_ITEM_INDEX_DOCUMENT_ID}`) lives in the same collection but uses a
 * different shape ({@link PagedItemIndexData}); from the model service's perspective only the
 * page envelope is the canonical document.
 */
export type MockItemPagedDocumentData = PagedItemPageData<MockItemPagedEntry>;
/**
 * {@link AbstractFirestoreDocumentWithParent} implementation for a single page document inside a
 * {@link MockItemPagedFirestoreCollection}. Used by the model service factory to address pages
 * the same way other subcollection documents are addressed.
 */
export declare class MockItemPagedDocument extends AbstractFirestoreDocumentWithParent<MockItem, MockItemPagedDocumentData, MockItemPagedDocument, typeof mockItemPagedIdentity> {
    get modelIdentity(): import("@dereekb/firebase").FirestoreModelIdentityWithParent<import("@dereekb/firebase").RootFirestoreModelIdentity<"mockItem", "mi">, "mockItemPaged", "mip2">;
}
/**
 * Per-item converter for {@link MockItemPagedEntry} used by the paged accessor.
 *
 * The mock entry shape is already Firestore-safe, so the converter is an identity
 * pass-through. Production usage may wrap a real converter (e.g. for date fields).
 */
export declare const MOCK_ITEM_PAGED_ENTRY_CONVERTER: PagedItemConverter<MockItemPagedEntry>;
/**
 * Static distribution scheme for {@link MockItemPagedEntry} that buckets items by their
 * {@link MockItemPagedEntry.group} field across three page IDs (`a`, `b`, `c`).
 */
export declare const MOCK_ITEM_PAGED_ALPHA_DISTRIBUTION_SCHEME: PagedItemDistributionScheme<MockItemPagedEntry>;
/**
 * Default `maxItemsPerPage` used by the dynamic mock paged collection factory. Kept small to
 * exercise multi-page boundary conditions in tests without writing many entries.
 */
export declare const DEFAULT_MOCK_ITEM_PAGED_MAX_ITEMS_PER_PAGE = 3;
/**
 * Typed {@link PagedItemFirestoreCollection} for {@link MockItemPagedEntry} items under a
 * {@link MockItem} parent.
 */
export type MockItemPagedFirestoreCollection = PagedItemFirestoreCollection<MockItemPagedEntry, MockItem, MockItemPagedDocument, MockItemDocument>;
/**
 * Factory function type that creates a {@link MockItemPagedFirestoreCollection} for a given parent.
 */
export type MockItemPagedFirestoreCollectionFactory = (parent: MockItemDocument) => MockItemPagedFirestoreCollection;
/**
 * Configuration for {@link mockItemPagedFirestoreCollection}.
 */
export interface MockItemPagedFirestoreCollectionConfig {
    /**
     * When provided, the factory produces a statically-distributed paged collection using the
     * given scheme. When omitted, the factory produces a dynamic (count-based) paged collection
     * using {@link maxItemsPerPage}.
     */
    readonly distributionScheme?: PagedItemDistributionScheme<MockItemPagedEntry>;
    /**
     * Maximum items per page document in dynamic mode. Defaults to
     * {@link DEFAULT_MOCK_ITEM_PAGED_MAX_ITEMS_PER_PAGE}.
     */
    readonly maxItemsPerPage?: number;
}
/**
 * Creates a factory for producing {@link MockItemPagedFirestoreCollection} instances bound to a
 * parent {@link MockItemDocument}.
 *
 * @param firestoreContext - The Firestore context used to resolve the underlying subcollection.
 * @param config - Optional config selecting between dynamic (default) and static distribution.
 * @returns A factory that, given a parent {@link MockItemDocument}, returns a paged subcollection
 * wired with {@link MOCK_ITEM_PAGED_ENTRY_CONVERTER}.
 */
export declare function mockItemPagedFirestoreCollection(firestoreContext: FirestoreContext, config?: MockItemPagedFirestoreCollectionConfig): MockItemPagedFirestoreCollectionFactory;
/**
 * Creates a {@link CollectionGroup} reference for querying all {@link MockItemPagedDocumentData}
 * page documents across parents.
 *
 * Note: the index document (`_index`) lives in the same Firestore collection but has a different
 * shape ({@link PagedItemIndexData}); collection-group queries will surface both. Consumers
 * should filter by document id when only pages are desired.
 *
 * @param context - The Firestore context used to resolve the collection group.
 * @returns A typed {@link CollectionGroup} reference for the MockItemPaged collection name.
 */
export declare function mockItemPagedCollectionReference(context: FirestoreContext): CollectionGroup<MockItemPagedDocumentData>;
/**
 * Typed {@link FirestoreCollectionGroup} for querying {@link MockItemPagedDocumentData} page
 * documents across all parents. Used by the model service factory to address paged page
 * documents in a parent-agnostic way.
 */
export type MockItemPagedFirestoreCollectionGroup = FirestoreCollectionGroup<MockItemPagedDocumentData, MockItemPagedDocument>;
/**
 * Creates a {@link MockItemPagedFirestoreCollectionGroup} for cross-parent access to paged
 * page documents.
 *
 * @param firestoreContext - The Firestore context used to resolve the underlying collection group reference.
 * @returns A typed {@link MockItemPagedFirestoreCollectionGroup}.
 */
export declare function mockItemPagedFirestoreCollectionGroup(firestoreContext: FirestoreContext): MockItemPagedFirestoreCollectionGroup;
/**
 * System state type identifier for mock system state data.
 *
 * Used as the key in {@link MOCK_ITEM_SYSTEM_STATE_STORED_DATA_CONVERTER_MAP}.
 */
export declare const MOCK_SYSTEM_STATE_TYPE = "mockitemsystemstate";
/**
 * Custom data stored within a mock system state document.
 *
 * Extends {@link SystemStateStoredData} with a `lat` (last-updated-at) timestamp field
 * to test sub-object field conversion in system state documents.
 */
export interface MockSystemData extends SystemStateStoredData {
    /**
     * Last updated at
     */
    lat: Date;
}
/**
 * Field converter config for {@link MockSystemData}, handling the `lat` date field conversion.
 */
export declare const mockItemSystemDataConverter: SystemStateStoredDataFieldConverterConfig<MockSystemData>;
/**
 * Maps system state type identifiers to their corresponding field converter configs.
 *
 * Used when creating the mock system state Firestore collection to register
 * the {@link MockSystemData} converter under the {@link MOCK_SYSTEM_STATE_TYPE} key.
 */
export declare const MOCK_ITEM_SYSTEM_STATE_STORED_DATA_CONVERTER_MAP: SystemStateStoredDataConverterMap;