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 } 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;
/**
 * {@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 firestore
 * @returns
 */
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}.
 *
 * @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>>>;
/**
 * Used to build a mockItemCollection from a firestore instance with a converter setup.
 *
 * @param firestore
 * @returns
 */
/**
 * Creates a factory that produces {@link CollectionReference} instances for {@link MockItemPrivate}
 * subcollections under a given {@link MockItemDocument} parent.
 */
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}.
 */
export declare function mockItemPrivateFirestoreCollection(firestoreContext: FirestoreContext): MockItemPrivateFirestoreCollectionFactory;
/**
 * Creates a {@link CollectionGroup} reference for querying all {@link MockItemPrivate} documents across parents.
 */
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}.
 */
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 mockItemUserCollectionName = "mockItemUser";
/**
 * Default document identifier used for MockItemUser in tests.
 */
export declare const mockItemUserIdentifier = "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>>>;
/**
 * Used to build a mockItemCollection from a firestore instance with a converter setup.
 *
 * @param firestore
 * @returns
 */
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}.
 */
export declare function mockItemUserFirestoreCollection(firestoreContext: FirestoreContext): MockItemUserFirestoreCollectionFactory;
/**
 * Creates a {@link CollectionGroup} reference for querying all {@link MockItemUser} documents across parents.
 */
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}.
 */
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.
 */
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}.
 */
export declare function mockItemSubItemFirestoreCollection(firestoreContext: FirestoreContext): MockItemSubItemFirestoreCollectionFactory;
/**
 * Creates a {@link CollectionGroup} reference for querying all {@link MockItemSubItem} documents across parents.
 */
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}.
 */
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.
 */
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}.
 */
export declare function mockItemSubItemDeepFirestoreCollection(firestoreContext: FirestoreContext): MockItemSubItemDeepFirestoreCollectionFactory;
/**
 * Creates a {@link CollectionGroup} reference for querying all {@link MockItemSubItemDeep} documents across parents.
 */
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}.
 */
export declare function mockItemSubItemDeepFirestoreCollectionGroup(firestoreContext: FirestoreContext): MockItemSubItemDeepFirestoreCollectionGroup;
/**
 * System state type identifier for mock system state data.
 *
 * Used as the key in {@link mockItemSystemStateStoredDataConverterMap}.
 */
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 mockItemSystemStateStoredDataConverterMap: SystemStateStoredDataConverterMap;