/**
 * @module snapshot.field
 *
 * Provides pre-built Firestore field mapping configurations for converting between application model types and
 * their Firestore-stored representations. Each field converter is a factory function that returns a
 * {@link FirestoreModelFieldMapFunctionsConfig}, which plugs into the snapshot converter system
 * (see {@link snapshotConverterFunctions} in `snapshot.ts`).
 *
 * ## Pattern
 *
 * Every field type has a required variant (e.g., `firestoreString()`) and an optional variant
 * (e.g., `optionalFirestoreString()`). Required variants provide a default value when the field
 * is missing from Firestore; optional variants return `null`/`undefined`.
 *
 * ## Storage Optimization
 *
 * Optional fields support `dontStoreIf` / `dontStoreValueIf` to skip storing values that match a
 * condition (e.g., don't store `false` booleans or empty arrays). This reduces Firestore document
 * size and read costs. The value is still returned correctly on read via `defaultReadValue`.
 *
 * ## Available Field Types
 *
 * - **Primitives**: `firestoreString`, `firestoreNumber`, `firestoreBoolean`, `firestoreEnum`
 * - **Dates**: `firestoreDate` (ISO8601), `firestoreDateNumber` (unix seconds)
 * - **Arrays**: `firestoreArray`, `firestoreUniqueArray`, `firestoreEnumArray`, `firestoreEncodedArray`
 * - **Maps**: `firestoreMap`, `firestoreEncodedObjectMap`, `firestoreArrayMap`
 * - **Objects**: `firestoreSubObject`, `firestoreObjectArray`
 * - **Specialized**: `firestoreUID`, `firestoreLatLngString`, `firestoreWebsiteLink`,
 *   `firestoreDateCellRange`, `firestoreBitwiseSet`, `firestoreUnitedStatesAddress`
 */
import { type WebsiteLink, type GrantedRole, type WebsiteFileLink } from '@dereekb/model';
import { type DateCellRange, type DateCellSchedule } from '@dereekb/date';
import { type ModelFieldMapFunctionsConfig, type GetterOrValue, type Maybe, type ModelFieldMapConvertFunction, type PrimativeKey, type ReadKeyFunction, type ModelFieldMapFunctionsWithDefaultsConfig, type FilterUniqueStringsTransformConfig, type MapFunction, type FilterKeyValueTuplesInput, type ModelKey, type ToModelMapFunctionsInput, type ModelMapFunctionsRef, type LatLngPrecision, type LatLngString, type TimezoneString, type PrimativeKeyStringDencoderFunction, type PrimativeKeyDencoderFunction, type UnitedStatesAddress, type ZoomLevel, type FilterUniqueFunction, type BitwiseEncodedSet, type BitwiseObjectDencoder, type SortCompareFunctionRef, type TransformNumberFunctionConfigInput, type TransformStringFunctionConfigInput, type DecisionFunction, type ISO8601DateString, type FilterFunction } from '@dereekb/util';
import { type FirestoreModelData } from './snapshot.type';
/**
 * Base configuration for Firestore field mapping.
 *
 * @template V - Value type for the field in the model
 * @template D - Data type for the field in Firestore (defaults to unknown)
 */
export interface BaseFirestoreFieldConfig<V, D = unknown> {
    /**
     * Function to convert from Firestore data (D) to model value (V)
     */
    fromData: ModelFieldMapConvertFunction<D, V>;
    /**
     * Function to convert from model value (V) to Firestore data (D)
     */
    toData: ModelFieldMapConvertFunction<V, D>;
    /**
     * Optional default value to use before saving if the value is null/undefined
     */
    defaultBeforeSave?: GetterOrValue<D | null>;
}
/**
 * Default value for firestoreField().
 */
export interface FirestoreFieldDefault<V> {
    /**
     * Default value to retrieve when a null/undefined value is encountered.
     *
     * Input objects that are passed without a Getter are transformed into an ObjectCopyFactory, so copies are already returned.
     */
    default: GetterOrValue<V>;
}
/**
 * Default Data value for firestoreField().
 */
export interface FirestoreFieldDefaultData<D = unknown> {
    /**
     * Default value to apply when a null/undefined value is encountered.
     *
     * Input objects that are passed without a Getter are transformed into an ObjectCopyFactory, so copies are already returned.
     */
    defaultData: GetterOrValue<D>;
}
/**
 * Configuration for Firestore field with a default value for the model.
 *
 * @template V - Value type for the field in the model
 * @template D - Data type for the field in Firestore (defaults to unknown)
 */
export interface FirestoreFieldConfigWithDefault<V, D = unknown> extends BaseFirestoreFieldConfig<V, D>, FirestoreFieldDefault<V> {
}
/**
 * Configuration for Firestore field with a default value for the Firestore data.
 *
 * @template V - Value type for the field in the model
 * @template D - Data type for the field in Firestore (defaults to unknown)
 */
export interface FirestoreFieldConfigWithDefaultData<V, D = unknown> extends BaseFirestoreFieldConfig<V, D>, FirestoreFieldDefaultData<D> {
}
/**
 * Configuration for Firestore field that can have either a default value for the model
 * or a default value for the Firestore data.
 *
 * @template V - Value type for the field in the model
 * @template D - Data type for the field in Firestore (defaults to unknown)
 */
export type FirestoreFieldConfig<V, D = unknown> = FirestoreFieldConfigWithDefault<V, D> | FirestoreFieldConfigWithDefaultData<V, D>;
/**
 * The standard field mapping config type used by all Firestore field converters.
 *
 * The read side accepts `Maybe<D>` (nullable) because Firestore documents are schemaless — any field
 * can be missing or null. This design ensures the system gracefully handles incomplete documents.
 *
 * @template V - Value type in the application model
 * @template D - Data type in Firestore
 */
export type FirestoreModelFieldMapFunctionsConfig<V, D> = ModelFieldMapFunctionsWithDefaultsConfig<V, Maybe<D>>;
/**
 * Creates a Firestore field mapping configuration.
 *
 * This is the low-level building block that all other field converters (e.g., {@link firestoreString},
 * {@link firestoreDate}) delegate to. It generates `from`/`to` mapping functions that handle defaults
 * and conversions in both directions.
 *
 * Use the higher-level field converters for common types; use this directly only when you need a
 * custom conversion not covered by the built-in converters.
 *
 * @template V - Value type for the field in the model
 * @template D - Data type for the field in Firestore (defaults to unknown)
 * @param config - Configuration for the Firestore field
 * @returns A configured mapping between model and Firestore data
 *
 * @example
 * ```ts
 * // Custom field that stores a Set<string> as a comma-separated string
 * const tagsField = firestoreField<Set<string>, string>({
 *   default: () => new Set(),
 *   fromData: (csv) => new Set(csv.split(',')),
 *   toData: (set) => [...set].join(',')
 * });
 * ```
 */
export declare function firestoreField<V, D = unknown>(config: FirestoreFieldConfig<V, D>): FirestoreModelFieldMapFunctionsConfig<V, D>;
/**
 * A pre-built passthrough field mapping that stores and reads values unchanged.
 *
 * Defaults to `null` when the field is missing. Used internally by {@link firestorePassThroughField}
 * and as a fallback for {@link optionalFirestoreField} when no config is provided.
 */
export declare const FIRESTORE_PASSTHROUGH_FIELD: FirestoreModelFieldMapFunctionsConfig<unknown, unknown>;
/**
 * Creates a pass-through field mapping configuration that doesn't transform the data.
 *
 * This is useful when the model field and Firestore field are the same type and
 * no transformation is needed in either direction.
 *
 * @template T - Type for both the model field and Firestore field
 * @returns A field mapping configuration that passes values through unchanged
 */
export declare function firestorePassThroughField<T>(): ModelFieldMapFunctionsConfig<T, T>;
/**
 * Configuration for optional Firestore fields with conditional storage.
 *
 * Enables storage optimization by skipping fields that match a "don't store" condition.
 * This reduces Firestore document size and cost. The field is still read correctly because
 * `defaultReadValue` provides the expected value when the field is absent from the document.
 *
 * The optimization flow:
 * 1. On write: if the value matches `dontStoreValueIf` (pre-transform) or `dontStoreIf` (post-transform), store `null` instead
 * 2. On read: if the stored value is `null`/`undefined`, return `defaultReadValue` (if configured) before transforming
 *
 * @template V - Value type for the field in the model
 * @template D - Data type for the field in Firestore
 */
export interface OptionalFirestoreFieldConfig<V, D> {
    /**
     * Removes the value from the object if the decision returns true.
     *
     * This check occurs **before** the value is transformed to Firestore data format.
     * Can be a specific value (compared with `===`) or a decision function.
     */
    readonly dontStoreValueIf?: V | DecisionFunction<V>;
    /**
     * Removes the value from the object if the decision returns true.
     *
     * This check occurs **after** the value is transformed to Firestore data format.
     * Can be a specific value (compared with `===`) or a decision function.
     */
    readonly dontStoreIf?: D | DecisionFunction<D>;
    /**
     * Default data value to return when the field is missing from the Firestore document.
     *
     * Pairs with `dontStoreIf`/`dontStoreValueIf` to enable storage optimization: don't store the value,
     * but return this default on read so the application sees the expected value.
     *
     * If using a getter, the getter is invoked each time to ensure fresh copies.
     */
    readonly defaultReadValue?: GetterOrValue<D>;
}
/**
 * Configuration for optional Firestore fields with the same type for model and Firestore.
 *
 * @template T - Type for both the model field and Firestore field
 */
export interface OptionalOneTypeFirestoreFieldConfig<T> extends OptionalFirestoreFieldConfig<T, T> {
    /**
     * Defaults the dontStoreIfValue value to this value.
     *
     * This is ignored if defaultReadValue is not set or if dontStoreIf is provided.
     */
    readonly dontStoreDefaultReadValue?: boolean;
}
/**
 * Configuration for optional Firestore fields with different types and transformations.
 *
 * @template V - Value type for the field in the model
 * @template D - Data type for the field in Firestore
 */
export interface OptionalFirestoreFieldConfigWithTwoTypeTransform<V, D> extends OptionalFirestoreFieldConfig<V, D> {
    /**
     * (Optional) Function to transform the data after it is read from Firestore.
     *
     * Only transforms non-null/undefined values from the database.
     *
     * Overrides transformData.
     */
    readonly transformFromData?: MapFunction<D, V>;
    /**
     * (Optional) Transform function that is only used before the data is stored to Firestore.
     *
     * Is allowed to return null to clear the stored value.
     *
     * Overrides transformData.
     */
    readonly transformToData?: MapFunction<V, D | null>;
}
/**
 * Configuration for optional Firestore fields with single type and transformation function.
 *
 * @template T - Type for both the model field and Firestore field
 */
export interface OptionalFirestoreFieldConfigWithOneTypeTransform<T> extends OptionalFirestoreFieldConfigWithTwoTypeTransform<T, T>, OptionalOneTypeFirestoreFieldConfig<T> {
    /**
     * (Optional) Function to transform the data before it is stored and after it is read.
     *
     * This is used as the default for transformToData, and transformToData.
     */
    readonly transformData?: MapFunction<T, T>;
}
/**
 * Creates a field mapping configuration for optional Firestore fields.
 *
 * Optional fields store `null` in Firestore when absent and return `null`/`undefined` to the application.
 * Supports conditional storage via `dontStoreIf`/`dontStoreValueIf` to reduce document size.
 *
 * When no config is provided, returns a passthrough field that stores/reads values unchanged.
 *
 * @template V - Value type for the field in the model
 * @template D - Data type for the field in Firestore
 * @param config - Configuration for the optional Firestore field
 * @returns A field mapping configuration for optional values
 *
 * @example
 * ```ts
 * // Optional boolean that isn't stored when false (saves document space)
 * const isAdminField = optionalFirestoreField<boolean>({
 *   dontStoreIf: false,
 *   defaultReadValue: false
 * });
 *
 * // Optional date with transformation
 * const deletedAtField = optionalFirestoreField<Date, string>({
 *   transformFromData: toJsDate,
 *   transformToData: toISODateString
 * });
 * ```
 */
export declare function optionalFirestoreField<V, D>(config?: OptionalFirestoreFieldConfigWithTwoTypeTransform<V, D>): FirestoreModelFieldMapFunctionsConfig<Maybe<V>, Maybe<D>>;
/**
 * Creates a field mapping configuration for optional Firestore fields with same type.
 *
 * Handles transformation and conditional storage of values of the same type.
 *
 * @template T - Type for both the model field and Firestore field
 * @param config - Configuration for the optional Firestore field
 * @returns A field mapping configuration for optional values
 */
export declare function optionalFirestoreField<T>(config?: OptionalFirestoreFieldConfigWithOneTypeTransform<T>): FirestoreModelFieldMapFunctionsConfig<Maybe<T>, Maybe<T>>;
/**
 * Configuration for a Firestore field with default model value but without conversion functions.
 *
 * @template V - Value type for the field in the model
 * @template D - Data type for the field in Firestore (defaults to unknown)
 */
export type MapConfiguredFirestoreFieldConfigWithDefault<V, D = unknown> = Omit<FirestoreFieldConfigWithDefault<V, D>, 'fromData' | 'toData'>;
/**
 * Configuration for a Firestore field with default data value but without conversion functions.
 *
 * @template V - Value type for the field in the model
 * @template D - Data type for the field in Firestore (defaults to unknown)
 */
export type MapConfiguredFirestoreFieldConfigWithDefaultData<V, D = unknown> = Omit<FirestoreFieldConfigWithDefaultData<V, D>, 'fromData' | 'toData'>;
/**
 * Configuration for a Firestore field with default values but without conversion functions.
 *
 * @template V - Value type for the field in the model
 * @template D - Data type for the field in Firestore (defaults to unknown)
 */
export type MapConfiguredFirestoreFieldConfig<V, D = unknown> = MapConfiguredFirestoreFieldConfigWithDefault<V, D> | MapConfiguredFirestoreFieldConfigWithDefaultData<V, D>;
/**
 * Configuration for a Firestore field with optional default model value but without conversion functions.
 *
 * @template V - Value type for the field in the model
 * @template D - Data type for the field in Firestore (defaults to unknown)
 */
export type DefaultMapConfiguredFirestoreFieldConfig<V, D = unknown> = Omit<FirestoreFieldConfigWithDefault<V, D>, 'fromData' | 'toData' | 'default'> & Partial<Pick<FirestoreFieldConfigWithDefault<V, D>, 'default'>>;
/**
 * Configuration for an optional Firestore field without conversion functions or defaults.
 *
 * @template V - Value type for the field in the model
 * @template D - Data type for the field in Firestore (defaults to unknown)
 */
export type OptionalMapConfiguredFirestoreFieldConfig<V, D = unknown> = Omit<BaseFirestoreFieldConfig<V, D>, 'fromData' | 'toData' | 'defaultBeforeSave'>;
/**
 * Configuration for a Firestore string field with optional transformation.
 *
 * @template S - String type for the field (defaults to string)
 */
export interface FirestoreStringConfig<S extends string = string> extends DefaultMapConfiguredFirestoreFieldConfig<S, S> {
    /**
     * Optional transformation to apply to the string value
     */
    readonly transform?: TransformStringFunctionConfigInput<S>;
}
/**
 * Default value for required Firestore string fields when the field is missing from the document.
 */
export declare const DEFAULT_FIRESTORE_STRING_FIELD_VALUE = "";
/**
 * Creates a field mapping configuration for Firestore string fields.
 *
 * Defaults to empty string `''` when the field is missing. Supports optional string
 * transformation (e.g., lowercase, trim) applied on both read and write.
 *
 * @template S - String type for the field (defaults to string)
 * @param config - Configuration for the string field
 * @returns A field mapping configuration for string values
 *
 * @example
 * ```ts
 * // Simple string field with default
 * const nameField = firestoreString({ default: 'unnamed' });
 *
 * // String field with lowercase transformation
 * const emailField = firestoreString({ transform: 'lowercase' });
 * ```
 */
export declare function firestoreString<S extends string = string>(config?: FirestoreStringConfig<S>): FirestoreModelFieldMapFunctionsConfig<S, S>;
/**
 * Configuration for an optional Firestore string field with transformation.
 *
 * @template S - String type for the field (defaults to string)
 */
export type OptionalFirestoreString<S extends string = string> = OptionalOneTypeFirestoreFieldConfig<S> & Pick<FirestoreStringConfig<S>, 'transform'>;
/**
 * Creates a field mapping configuration for optional Firestore string fields.
 *
 * @template S - String type for the field (defaults to string)
 * @param config - Configuration for the optional string field
 * @returns A field mapping configuration for optional string values
 */
export declare function optionalFirestoreString<S extends string = string>(config?: OptionalFirestoreString<S>): FirestoreModelFieldMapFunctionsConfig<Maybe<S>, Maybe<S>>;
/**
 * Configuration for a Firestore enum field.
 *
 * @template S - Enum type (string or number)
 */
export type FirestoreEnumConfig<S extends string | number> = MapConfiguredFirestoreFieldConfigWithDefault<S, S>;
/**
 * Creates a field mapping configuration for Firestore enum fields.
 *
 * @template S - Enum type (string or number)
 * @param config - Configuration for the enum field
 * @returns A field mapping configuration for enum values
 */
export declare function firestoreEnum<S extends string | number>(config: FirestoreEnumConfig<S>): FirestoreModelFieldMapFunctionsConfig<S, S>;
/**
 * Configuration for an optional Firestore enum field.
 *
 * @template S - Enum type (string or number)
 */
export type OptionalFirestoreEnumConfig<S extends string | number> = OptionalOneTypeFirestoreFieldConfig<S>;
/**
 * Creates a field mapping configuration for optional Firestore enum fields.
 *
 * @template S - Enum type (string or number)
 * @param config - Configuration for the optional enum field
 * @returns A field mapping configuration for optional enum values
 */
export declare function optionalFirestoreEnum<S extends string | number>(config?: OptionalFirestoreEnumConfig<S>): FirestoreModelFieldMapFunctionsConfig<Maybe<S>, Maybe<S>>;
/**
 * Creates a field mapping configuration for Firestore UID fields.
 *
 * @returns A field mapping configuration for Firebase Auth user IDs
 */
export declare function firestoreUID(): FirestoreModelFieldMapFunctionsConfig<string, string>;
/**
 * Creates a field mapping configuration for optional Firestore UID fields.
 *
 * @returns A field mapping configuration for optional Firebase Auth user IDs
 */
export declare function optionalFirestoreUID(): FirestoreModelFieldMapFunctionsConfig<Maybe<string>, Maybe<string>>;
/**
 * Pre-built field mapping for Firestore model key strings. Defaults to empty string.
 */
export declare const firestoreModelKeyString: FirestoreModelFieldMapFunctionsConfig<string, string>;
/**
 * Pre-built field mapping for Firestore model ID strings. Defaults to empty string.
 */
export declare const firestoreModelIdString: FirestoreModelFieldMapFunctionsConfig<string, string>;
/**
 * Configuration for a Firestore date field.
 *
 * @template Date - JavaScript Date object type
 * @template string - ISO8601 date string format in Firestore
 */
export type FirestoreDateFieldConfig = DefaultMapConfiguredFirestoreFieldConfig<Date, string> & {
    /**
     * Whether to save the default date as the current timestamp
     */
    readonly saveDefaultAsNow?: boolean;
};
/**
 * Creates a field mapping configuration for Firestore date fields.
 *
 * Handles conversion between JavaScript Date objects and ISO8601 strings stored in Firestore.
 * Defaults to `new Date()` when the field is missing. Use `saveDefaultAsNow` to automatically
 * store the current timestamp when a new document is created.
 *
 * @param config - Configuration for the date field
 * @returns A field mapping configuration for Date values
 *
 * @example
 * ```ts
 * // Date field that auto-saves current time on creation
 * const createdAtField = firestoreDate({ saveDefaultAsNow: true });
 *
 * // Date field with a fixed default
 * const startDateField = firestoreDate({ default: new Date('2020-01-01') });
 * ```
 */
export declare function firestoreDate(config?: FirestoreDateFieldConfig): FirestoreModelFieldMapFunctionsConfig<Date, string>;
/**
 * Configuration for an optional Firestore date field.
 *
 * @template Date - JavaScript Date object type
 * @template ISO8601DateString - ISO8601 date string format in Firestore
 */
export type OptionalFirestoreDateFieldConfig = OptionalFirestoreFieldConfig<Date, ISO8601DateString>;
/**
 * Creates a field mapping configuration for optional Firestore date fields.
 *
 * Handles conversion between JavaScript Date objects and ISO8601 strings stored in Firestore.
 *
 * @param config - Configuration for the optional date field
 * @returns A field mapping configuration for optional Date values
 */
export declare function optionalFirestoreDate(config?: OptionalFirestoreDateFieldConfig): FirestoreModelFieldMapFunctionsConfig<Maybe<Date>, Maybe<string>>;
/**
 * Configuration for a Firestore date field that is stored as a number.
 */
export type FirestoreDateNumberFieldConfig = DefaultMapConfiguredFirestoreFieldConfig<Date, number> & {
    /**
     * Whether to save the default date as the current timestamp
     */
    readonly saveDefaultAsNow?: boolean;
    /**
     * Converts a Date object to a number.
     */
    readonly fromDate: (input: Date) => number;
    /**
     * Converts a number to a Date object.
     */
    readonly toDate: (input: number) => Date;
};
/**
 * Creates a field mapping configuration for Firestore date fields stored as numbers.
 *
 * Handles conversion between JavaScript Date objects and numeric representations
 * using the provided `fromDate`/`toDate` conversion functions.
 *
 * @param config - Configuration including custom Date-to-number conversion functions
 * @returns A field mapping configuration for Date values stored as numbers
 */
export declare function firestoreDateNumber(config: FirestoreDateNumberFieldConfig): FirestoreModelFieldMapFunctionsConfig<Date, number>;
/**
 * Configuration for an optional Firestore date field.
 *
 * @template Date - JavaScript Date object type
 * @template ISO8601DateString - ISO8601 date string format in Firestore
 */
export type OptionalFirestoreDateNumberFieldConfig = OptionalFirestoreFieldConfig<Date, number> & Pick<FirestoreDateNumberFieldConfig, 'fromDate' | 'toDate'>;
/**
 * Creates a field mapping configuration for optional Firestore date field that is stored as a number.
 *
 * @param config - Configuration for the optional date field
 * @returns A field mapping configuration for optional Date values
 */
export declare function optionalFirestoreDateNumber(config: OptionalFirestoreDateNumberFieldConfig): FirestoreModelFieldMapFunctionsConfig<Maybe<Date>, Maybe<number>>;
export type FirestoreUnixDateTimeSecondsNumberFieldConfig = Omit<FirestoreDateNumberFieldConfig, 'fromDate' | 'toDate'>;
/**
 * Creates a field mapping configuration for Firestore Date fields that are stored as a UnixDateTimeSecondsNumber.
 *
 * @param config - Configuration for the date field
 * @returns A field mapping configuration for Date values
 */
export declare function firestoreUnixDateTimeSecondsNumber(config: FirestoreUnixDateTimeSecondsNumberFieldConfig): FirestoreModelFieldMapFunctionsConfig<Date, number>;
export type OptionalFirestoreUnixDateTimeSecondsNumberFieldConfig = Omit<OptionalFirestoreDateNumberFieldConfig, 'fromDate' | 'toDate'>;
/**
 * Creates a field mapping configuration for optional Firestore Date fields that are stored as a UnixDateTimeSecondsNumber.
 *
 * @param config - Configuration for the optional date field
 * @returns A field mapping configuration for optional Date values
 */
export declare function optionalFirestoreUnixDateTimeSecondsNumber(config?: OptionalFirestoreUnixDateTimeSecondsNumberFieldConfig): FirestoreModelFieldMapFunctionsConfig<Maybe<Date>, Maybe<number>>;
/**
 * Configuration for a Firestore boolean field.
 */
export type FirestoreBooleanFieldConfig = MapConfiguredFirestoreFieldConfigWithDefault<boolean, boolean>;
/**
 * Creates a field mapping configuration for Firestore boolean fields.
 *
 * @param config - Configuration for the boolean field
 * @returns A field mapping configuration for boolean values
 */
export declare function firestoreBoolean(config: FirestoreBooleanFieldConfig): FirestoreModelFieldMapFunctionsConfig<boolean, boolean>;
/**
 * Configuration for an optional Firestore boolean field.
 */
export type OptionalFirestoreBooleanFieldConfig = OptionalOneTypeFirestoreFieldConfig<boolean>;
/**
 * Creates a field mapping configuration for optional Firestore boolean fields.
 *
 * @param config - Configuration for the optional boolean field
 * @returns A field mapping configuration for optional boolean values
 */
export declare function optionalFirestoreBoolean(config?: OptionalFirestoreBooleanFieldConfig): FirestoreModelFieldMapFunctionsConfig<Maybe<boolean>, Maybe<boolean>>;
/**
 * Configuration for a Firestore number field with optional transformation.
 *
 * @template N - Number type for the field (defaults to number)
 */
export interface FirestoreNumberConfig<N extends number = number> extends MapConfiguredFirestoreFieldConfigWithDefault<N, N> {
    /**
     * Whether to save the default value if no value is provided
     */
    readonly saveDefault?: Maybe<boolean>;
    /**
     * Optional transformation to apply to the number value
     */
    readonly transform?: TransformNumberFunctionConfigInput<N>;
}
/**
 * Creates a field mapping configuration for Firestore number fields.
 *
 * @template N - Number type for the field (defaults to number)
 * @param config - Configuration for the number field
 * @returns A field mapping configuration for number values
 */
export declare function firestoreNumber<N extends number = number>(config: FirestoreNumberConfig<N>): FirestoreModelFieldMapFunctionsConfig<N, N>;
/**
 * Configuration for an optional Firestore number field with transformation.
 *
 * @template N - Number type for the field (defaults to number)
 */
export type OptionalFirestoreNumberFieldConfig<N extends number = number> = OptionalOneTypeFirestoreFieldConfig<N> & Pick<FirestoreNumberConfig<N>, 'transform'>;
/**
 * Creates a field mapping configuration for optional Firestore number fields.
 *
 * @template N - Number type for the field (defaults to number)
 * @param config - Configuration for the optional number field
 * @returns A field mapping configuration for optional number values
 */
export declare function optionalFirestoreNumber<N extends number = number>(config?: OptionalFirestoreNumberFieldConfig<N>): FirestoreModelFieldMapFunctionsConfig<Maybe<N>, Maybe<N>>;
/**
 * Configuration for a Firestore array field with optional sorting.
 *
 * @template T - Type of elements in the array
 */
export type FirestoreArrayFieldConfig<T> = DefaultMapConfiguredFirestoreFieldConfig<T[], T[]> & Partial<SortCompareFunctionRef<T>> & Partial<FirestoreFieldDefault<T[]>>;
/**
 * Creates a field mapping configuration for Firestore array fields.
 *
 * Defaults to an empty array when the field is missing. Supports optional sorting
 * via `sortWith` which is applied on both read and write.
 *
 * @template T - Type of elements in the array
 * @param config - Configuration for the array field
 * @returns A field mapping configuration for array values
 *
 * @example
 * ```ts
 * // Array of strings sorted alphabetically
 * const tagsField = firestoreArray<string>({
 *   sortWith: (a, b) => a.localeCompare(b)
 * });
 * ```
 */
export declare function firestoreArray<T>(config: FirestoreArrayFieldConfig<T>): FirestoreModelFieldMapFunctionsConfig<T[], T[]>;
/**
 * Configuration for an optional Firestore array field with filtering and sorting options.
 *
 * @template T - Type of elements in the array
 */
export type OptionalFirestoreArrayFieldConfig<T> = Omit<OptionalFirestoreFieldConfigWithOneTypeTransform<T[]>, 'dontStoreIf' | 'dontStoreIfValue' | 'transformFromData' | 'transformToData'> & Pick<FirestoreArrayFieldConfig<T>, 'sortWith'> & {
    /**
     * Filters the function uniquely. If true uses the unique function.
     */
    readonly filterUnique?: T extends PrimativeKey ? FilterUniqueFunction<T, T> | true : never;
    /**
     * Removes the value from the object if the decision returns true.
     */
    readonly dontStoreIf?: DecisionFunction<T[]>;
    /**
     * The array is not stored if it is empty.
     *
     * Defaults to false.
     */
    readonly dontStoreIfEmpty?: boolean;
};
/**
 * Creates a field mapping configuration for optional Firestore array fields.
 *
 * Supports unique filtering and conditional storage based on array content.
 *
 * @template T - Type of elements in the array
 * @param config - Configuration for the optional array field
 * @returns A field mapping configuration for optional array values
 */
export declare function optionalFirestoreArray<T>(config?: OptionalFirestoreArrayFieldConfig<T>): FirestoreModelFieldMapFunctionsConfig<Maybe<T[]>, Maybe<T[]>>;
/**
 * Configuration for a Firestore array field with unique filtering.
 *
 * @template T - Type of elements in the array
 * @template K - Key type for filtering uniqueness (defaults to T if it's a primative key)
 */
export type FirestoreUniqueArrayFieldConfig<T, K extends PrimativeKey = T extends PrimativeKey ? T : PrimativeKey> = FirestoreArrayFieldConfig<T> & Partial<SortCompareFunctionRef<T>> & {
    /**
     * Function to filter array elements for uniqueness
     */
    readonly filterUnique: FilterUniqueFunction<T, K> | true;
};
/**
 * Creates a field mapping configuration for Firestore array fields with unique filtering.
 *
 * @template T - Type of elements in the array
 * @template K - Key type for filtering uniqueness
 * @param config - Configuration for the unique array field
 * @returns A field mapping configuration for unique array values
 */
export declare function firestoreUniqueArray<T, K extends PrimativeKey = T extends PrimativeKey ? T : PrimativeKey>(config: FirestoreUniqueArrayFieldConfig<T, K>): FirestoreModelFieldMapFunctionsConfig<T[], T[]>;
/**
 * Configuration for a Firestore array field with unique filtering based on a key function.
 *
 * @template T - Type of elements in the array
 * @template K - Type of the key used for uniqueness (defaults to PrimativeKey)
 */
export type FirestoreUniqueKeyedArrayFieldConfig<T, K extends PrimativeKey = PrimativeKey> = FirestoreArrayFieldConfig<T> & {
    /**
     * Function to extract the key from an array element for uniqueness checking
     */
    readonly readKey: ReadKeyFunction<T, K>;
};
/**
 * Creates a field mapping configuration for Firestore array fields with unique filtering based on a key function.
 *
 * @template T - Type of elements in the array
 * @template K - Type of the key used for uniqueness
 * @param config - Configuration for the keyed unique array field
 * @returns A field mapping configuration for keyed unique array values
 */
export declare function firestoreUniqueKeyedArray<T, K extends PrimativeKey = PrimativeKey>(config: FirestoreUniqueKeyedArrayFieldConfig<T, K>): FirestoreModelFieldMapFunctionsConfig<T[], T[]>;
/**
 * Configuration for a Firestore array field of enum values.
 *
 * @template S - Enum type (string or number)
 */
export type FirestoreEnumArrayFieldConfig<S extends string | number> = Omit<FirestoreUniqueArrayFieldConfig<S>, 'filterUnique'>;
/**
 * Creates a field mapping configuration for Firestore array fields of unique enum values.
 *
 * @template S - Enum type (string or number)
 * @param config - Configuration for the enum array field
 * @returns A field mapping configuration for enum array values
 */
export declare function firestoreEnumArray<S extends string | number>(config?: FirestoreEnumArrayFieldConfig<S>): FirestoreModelFieldMapFunctionsConfig<S[], S[]>;
/**
 * Configuration for a Firestore array field of unique string values.
 *
 * @template S - String type (defaults to string)
 */
export type FirestoreUniqueStringArrayFieldConfig<S extends string = string> = Omit<FirestoreUniqueArrayFieldConfig<S>, 'filterUnique'> & FilterUniqueStringsTransformConfig;
/**
 * Creates a field mapping configuration for Firestore array fields of unique string values.
 *
 * @template S - String type (defaults to string)
 * @param config - Configuration for the unique string array field
 * @returns A field mapping configuration for unique string array values
 */
export declare function firestoreUniqueStringArray<S extends string = string>(config?: FirestoreUniqueStringArrayFieldConfig<S>): FirestoreModelFieldMapFunctionsConfig<S[], S[]>;
/**
 * Pre-built field mapping for arrays of unique Firestore model key strings.
 */
export declare const firestoreModelKeyArrayField: FirestoreModelFieldMapFunctionsConfig<string[], string[]>;
/**
 * Pre-built field mapping for arrays of unique Firestore model ID strings.
 * Alias for {@link firestoreModelKeyArrayField}.
 */
export declare const firestoreModelIdArrayField: FirestoreModelFieldMapFunctionsConfig<string[], string[]>;
/**
 * Configuration for a Firestore array field of unique number values.
 *
 * @template S - Number type (defaults to number)
 */
export type FirestoreUniqueNumberArrayFieldConfig<S extends number = number> = Omit<FirestoreUniqueArrayFieldConfig<S>, 'filterUnique'>;
/**
 * Creates a field mapping configuration for Firestore array fields of unique number values.
 *
 * @template S - Number type (defaults to number)
 * @param config - Configuration for the unique number array field
 * @returns A field mapping configuration for unique number array values
 */
export declare function firestoreUniqueNumberArray<S extends number = number>(config?: FirestoreUniqueNumberArrayFieldConfig<S>): FirestoreModelFieldMapFunctionsConfig<S[], S[]>;
/**
 * Configuration for a Firestore array field with custom encoding/decoding of values.
 *
 * @template T - Type of elements in the model array
 * @template E - Type of encoded elements in Firestore (string or number)
 */
export type FirestoreEncodedArrayFieldConfig<T, E extends string | number> = DefaultMapConfiguredFirestoreFieldConfig<T[], E[]> & Partial<SortCompareFunctionRef<T>> & {
    /**
     * Conversion functions for encoding/decoding array elements
     */
    readonly convert: {
        /**
         * Function to convert from Firestore data to model value
         */
        fromData: MapFunction<E, T>;
        /**
         * Function to convert from model value to Firestore data
         */
        toData: MapFunction<T, E>;
    };
};
/**
 * Creates a field mapping configuration for Firestore array fields with custom encoding.
 *
 * Encodes model values to string or number representations for storage, and decodes them on read.
 * Useful when the model type is richer than what should be stored directly in Firestore.
 *
 * @template T - Type of elements in the model array
 * @template E - Type of encoded elements in Firestore (string or number)
 * @param config - Configuration for the encoded array field
 * @returns A field mapping configuration for encoded array values
 */
export declare function firestoreEncodedArray<T, E extends string | number>(config: FirestoreEncodedArrayFieldConfig<T, E>): FirestoreModelFieldMapFunctionsConfig<T[], E[]>;
/**
 * Configuration for a Firestore array field with primative key encoding/decoding.
 *
 * @template D - Type of decoded elements in the model array
 * @template E - Type of encoded elements in Firestore
 */
export type FirestoreDencoderArrayFieldConfig<D extends PrimativeKey, E extends PrimativeKey> = DefaultMapConfiguredFirestoreFieldConfig<D[], E[]> & {
    /**
     * Function that handles both encoding and decoding of array elements
     */
    readonly dencoder: PrimativeKeyDencoderFunction<D, E>;
};
/**
 * Creates a field mapping configuration for Firestore array fields using a dencoder (encode/decode) function.
 *
 * The dencoder is a single function that handles both encoding (model → Firestore) and decoding
 * (Firestore → model) directions, leveraging {@link PrimativeKeyDencoderFunction}.
 *
 * @template D - Type of decoded elements in the model array
 * @template E - Type of encoded elements in Firestore
 * @param config - Configuration for the decoder array field
 * @returns A field mapping configuration for encoded primative key array values
 */
export declare function firestoreDencoderArray<D extends PrimativeKey, E extends PrimativeKey>(config: FirestoreDencoderArrayFieldConfig<D, E>): FirestoreModelFieldMapFunctionsConfig<D[], E[]>;
/**
 * Configuration for a Firestore array field that encodes primative keys to a string representation.
 *
 * @template D - Type of decoded elements in the model array
 * @template E - Type of encoded elements (intermediate representation)
 * @template S - String type for storage in Firestore
 */
export type FirestoreDencoderStringArrayFieldConfig<D extends PrimativeKey, E extends PrimativeKey, S extends string = string> = DefaultMapConfiguredFirestoreFieldConfig<D[], S> & {
    /**
     * Function that handles both encoding and decoding of array elements to/from string
     */
    readonly dencoder: PrimativeKeyStringDencoderFunction<D, E, S>;
};
/**
 * Creates a field mapping configuration for Firestore array fields that encode primative keys to a string representation.
 *
 * An array that is stored as an encoded string using a PrimativeKeyDencoderString configuration.
 *
 * @template D - Type of decoded elements in the model array
 * @template E - Type of encoded elements (intermediate representation)
 * @template S - String type for storage in Firestore
 * @param config - Configuration for the string decoder array field
 * @returns A field mapping configuration for string-encoded primative key array values
 */
export declare function firestoreDencoderStringArray<D extends PrimativeKey, E extends PrimativeKey, S extends string = string>(config: FirestoreDencoderStringArrayFieldConfig<D, E, S>): FirestoreModelFieldMapFunctionsConfig<D[], S>;
/**
 * A Firestore map type. Firestore/JSON maps only support string keys.
 *
 * @template T - Value type in the map
 * @template K - Key type (must extend string)
 */
export type FirestoreMapFieldType<T, K extends string = string> = Record<K, T>;
/**
 * Configuration for a {@link firestoreMap} field.
 */
export type FirestoreMapFieldConfig<T, K extends string = string> = DefaultMapConfiguredFirestoreFieldConfig<FirestoreMapFieldType<T, K>, FirestoreMapFieldType<T, K>> & Partial<FirestoreFieldDefault<FirestoreMapFieldType<T, K>>> & {
    /**
     * Optional filter to apply when saving to data.
     *
     * By default will filter all null/undefined values from maps.
     */
    readonly mapFilter?: FilterKeyValueTuplesInput<FirestoreMapFieldType<K>>;
    /**
     * Optional map function to apply to each input value before saving.
     */
    readonly mapFieldValues?: MapFunction<Maybe<T>, Maybe<T>>;
};
/**
 * Creates a field mapping configuration for Firestore map-type (key-value object) fields.
 *
 * By default, removes all null/undefined keys from the object before saving to Firestore.
 * Defaults to an empty object `{}` when the field is missing.
 *
 * @template T - Value type in the map
 * @template K - Key type (must be string, as Firestore maps only have string keys)
 * @param config - Configuration for the map field
 * @returns A field mapping configuration for map values
 *
 * @example
 * ```ts
 * // Map of user preferences
 * const prefsField = firestoreMap<string>({
 *   mapFilter: KeyValueTypleValueFilter.EMPTY
 * });
 * ```
 */
export declare function firestoreMap<T, K extends string = string>(config?: FirestoreMapFieldConfig<T, K>): FirestoreModelFieldMapFunctionsConfig<FirestoreMapFieldType<T, K>, FirestoreMapFieldType<T, K>>;
/**
 * FirestoreField configuration for a map of granted roles, keyed by model keys.
 *
 * Filters out models with no/null roles by default.
 *
 * @returns A field mapping configuration for a map of granted roles keyed by FirestoreModelKey
 */
export declare function firestoreModelKeyGrantedRoleMap<R extends GrantedRole>(): FirestoreModelFieldMapFunctionsConfig<FirestoreMapFieldType<R, string>, FirestoreMapFieldType<R, string>>;
/**
 * FirestoreField configuration for a map of granted roles, keyed by model ids.
 *
 * Filters out models with no/null roles by default.
 */
export declare const firestoreModelIdGrantedRoleMap: () => FirestoreModelFieldMapFunctionsConfig<FirestoreMapFieldType<ModelKey, string>, FirestoreMapFieldType<ModelKey, string>>;
/**
 * A Firestore map type where values are encoded from type `T` to type `E` for storage.
 */
export type FirestoreEncodedObjectMapFieldValueType<T, S extends string = string> = Record<S, T>;
export type FirestoreEncodedObjectMapFieldConfig<T, E, S extends string = string> = DefaultMapConfiguredFirestoreFieldConfig<FirestoreEncodedObjectMapFieldValueType<T, S>, FirestoreMapFieldType<E, S>> & Partial<FirestoreFieldDefault<FirestoreEncodedObjectMapFieldValueType<T, S>>> & {
    /**
     * Optional filter to apply when saving to data.
     *
     * By default will filter all null/undefined values from maps.
     */
    readonly mapFilter?: FilterKeyValueTuplesInput<FirestoreMapFieldType<E>>;
    /**
     * Encoder to map a value to the encoded/stored value.
     */
    readonly encoder: MapFunction<T, E>;
    /**
     * Encoder to map an encoded/stored value to a value.
     */
    readonly decoder: MapFunction<E, T>;
};
/**
 * Creates a field mapping configuration for Firestore map fields with encoded values.
 *
 * Each value in the map is encoded/decoded using the provided `encoder`/`decoder` functions.
 * By default, removes all empty/null keys from the map before saving.
 *
 * @template T - Decoded value type in the model
 * @template E - Encoded value type in Firestore
 * @template S - Key type (string, defaults to string)
 * @param config - Configuration including encoder/decoder functions
 * @returns A field mapping configuration for encoded map values
 */
export declare function firestoreEncodedObjectMap<T, E, S extends string = string>(config: FirestoreEncodedObjectMapFieldConfig<T, E, S>): FirestoreModelFieldMapFunctionsConfig<FirestoreEncodedObjectMapFieldValueType<T, S>, FirestoreMapFieldType<E, S>>;
export type FirestoreDencoderMapFieldValueType<D extends PrimativeKey, S extends string = string> = FirestoreEncodedObjectMapFieldValueType<D[], S>;
export type FirestoreDencoderMapFieldConfig<D extends PrimativeKey, E extends PrimativeKey, S extends string = string> = Omit<FirestoreEncodedObjectMapFieldConfig<D[], E, S>, 'encoder' | 'decoder'> & {
    /**
     * Dencoder to use for the input values.
     */
    readonly dencoder: PrimativeKeyStringDencoderFunction<D, E>;
};
/**
 * Creates a field mapping configuration for Firestore map fields using a dencoder function.
 *
 * Similar to {@link firestoreEncodedObjectMap} but uses a single dencoder function for both
 * encoding and decoding directions. By default, removes all empty/null keys from the map before saving.
 *
 * @template D - Decoded primative key type
 * @template E - Encoded primative key type
 * @template S - Key type for the map (string, defaults to string)
 * @param config - Configuration including the dencoder function
 * @returns A field mapping configuration for dencoder-mapped values
 */
export declare function firestoreDencoderMap<D extends PrimativeKey, E extends PrimativeKey, S extends string = string>(config: FirestoreDencoderMapFieldConfig<D, E, S>): FirestoreModelFieldMapFunctionsConfig<FirestoreEncodedObjectMapFieldValueType<D[], S>, FirestoreMapFieldType<E, S>>;
/**
 * FirestoreField configuration for a map of encoded granted roles, keyed by model keys.
 *
 * Filters out models with empty/no roles by default.
 *
 * @param dencoder - The dencoder function used to encode and decode the role values
 * @returns A field mapping configuration for an encoded granted role map keyed by FirestoreModelKey
 */
export declare function firestoreModelKeyEncodedGrantedRoleMap<D extends GrantedRole, E extends string>(dencoder: PrimativeKeyStringDencoderFunction<D, E>): FirestoreModelFieldMapFunctionsConfig<FirestoreEncodedObjectMapFieldValueType<D[], string>, FirestoreMapFieldType<E, string>>;
/**
 * A Firestore map where each value is an array of `T`.
 */
export type FirestoreArrayMapFieldType<T, K extends string = string> = FirestoreMapFieldType<T[], K>;
export type FirestoreArrayMapFieldConfig<T, K extends string = string> = FirestoreMapFieldConfig<T[], K>;
/**
 * Creates a field mapping configuration for Firestore map fields where each value is an array.
 *
 * Defaults to filtering empty arrays and null/undefined elements from each array before saving.
 *
 * @template T - Element type in the array values
 * @template K - Key type for the map (string)
 * @param config - Configuration for the array map field
 * @returns A field mapping configuration for map values with array entries
 */
export declare function firestoreArrayMap<T, K extends string = string>(config?: FirestoreArrayMapFieldConfig<T, K>): FirestoreModelFieldMapFunctionsConfig<FirestoreMapFieldType<T[], K>, FirestoreMapFieldType<T[], K>>;
/**
 * FirestoreField configuration for a map of granted roles, keyed by models keys.
 *
 * Filters empty roles/arrays by default.
 *
 * @returns A field mapping configuration for a map of granted role arrays keyed by FirestoreModelKey
 */
export declare function firestoreModelKeyGrantedRoleArrayMap<R extends GrantedRole>(): FirestoreModelFieldMapFunctionsConfig<FirestoreMapFieldType<R[], string>, FirestoreMapFieldType<R[], string>>;
/**
 * FirestoreField configuration for a map of granted roles, keyed by models ids.
 *
 * Filters empty roles/arrays by default.
 */
export declare const firestoreModelIdGrantedRoleArrayMap: () => FirestoreModelFieldMapFunctionsConfig<FirestoreMapFieldType<ModelKey[], string>, FirestoreMapFieldType<ModelKey[], string>>;
/**
 * firestoreObjectArray configuration
 */
export type FirestoreObjectArrayFieldConfig<T extends object, O extends object = FirestoreModelData<T>> = DefaultMapConfiguredFirestoreFieldConfig<T[], O[]> & (FirestoreObjectArrayFieldConfigObjectFieldInput<T, O> | FirestoreObjectArrayFieldConfigFirestoreFieldInput<T, O>) & Partial<SortCompareFunctionRef<T>> & {
    /**
     * Filters the objects array uniquely.
     */
    readonly filterUnique?: FilterUniqueFunction<T, any>;
    /**
     * Arbitrary filter to apply to the array. Is run after the filterUnique function is run.
     */
    readonly filter?: FilterFunction<T>;
};
export type FirestoreObjectArrayFieldConfigObjectFieldInput<T extends object, O extends object = FirestoreModelData<T>> = {
    /**
     * The field to use for conversion.
     */
    readonly objectField: ToModelMapFunctionsInput<T, O>;
};
export type FirestoreObjectArrayFieldConfigFirestoreFieldInput<T extends object, O extends object = FirestoreModelData<T>> = {
    /**
     * FirestoreModelFieldMapFunctionsConfig to use for conversion.
     */
    readonly firestoreField: FirestoreModelFieldMapFunctionsConfig<T, O>;
};
/**
 * Converts a {@link FirestoreModelFieldMapFunctionsConfig} into a {@link ModelMapFunctionsRef}.
 *
 * Used internally by {@link firestoreObjectArray} to adapt field configs into the map functions
 * format needed for array element conversion.
 *
 * @param config - The FirestoreModelFieldMapFunctionsConfig to convert
 * @returns A ModelMapFunctionsRef wrapping the derived map functions
 */
export declare function firestoreFieldConfigToModelMapFunctionsRef<T extends object, O extends object = FirestoreModelData<T>>(config: FirestoreModelFieldMapFunctionsConfig<T, O>): ModelMapFunctionsRef<T, O>;
/**
 * Creates a field mapping configuration for Firestore arrays of complex objects.
 *
 * Each element in the array is converted using its own set of field converters (via `objectField`
 * or `firestoreField`), enabling type-safe conversion of embedded document arrays.
 * Supports optional unique filtering and sorting.
 *
 * On write, null/undefined values are filtered from each object to match Firestore semantics.
 *
 * @template T - The element model type
 * @template O - The element Firestore data type (defaults to FirestoreModelData<T>)
 * @param config - Configuration including element conversions and optional filtering/sorting
 * @returns A field mapping configuration for object array values
 *
 * @example
 * ```ts
 * // Array of embedded item objects
 * const itemsField = firestoreObjectArray<NotificationItem>({
 *   objectField: notificationItemFields,
 *   sortWith: sortAscendingIndexNumberRefFunction()
 * });
 * ```
 */
export declare function firestoreObjectArray<T extends object, O extends object = FirestoreModelData<T>>(config: FirestoreObjectArrayFieldConfig<T, O>): FirestoreModelFieldMapFunctionsConfig<T[], O[]>;
/**
 * firestoreSubObjectField configuration
 */
export type FirestoreSubObjectFieldConfig<T extends object, O extends object = FirestoreModelData<T>> = DefaultMapConfiguredFirestoreFieldConfig<T, O> & {
    /**
     * Whether or not to save the default object. Is ignored if defaultBeforeSave is set.
     *
     * Is false by default.
     */
    readonly saveDefaultObject?: boolean;
    /**
     * The fields to use for conversion.
     */
    readonly objectField: ToModelMapFunctionsInput<T, O>;
};
export type FirestoreSubObjectFieldMapFunctionsConfig<T extends object, O extends object = FirestoreModelData<T>> = FirestoreModelFieldMapFunctionsConfig<T, O> & ModelMapFunctionsRef<T, O>;
/**
 * Creates a field mapping configuration for nested Firestore object fields.
 *
 * Maps a nested object using its own set of field converters, enabling recursive type-safe
 * conversion of embedded documents. The `objectField` defines the conversion rules for
 * the nested object's fields using the same converter patterns.
 *
 * @template T - The nested model type
 * @template O - The nested Firestore data type (defaults to FirestoreModelData<T>)
 * @param config - Configuration including nested field conversions
 * @returns A field mapping configuration with both field config and map functions
 *
 * @example
 * ```ts
 * // Nested address object with its own converters
 * const addressField = firestoreSubObject<Address>({
 *   objectField: {
 *     street: firestoreString(),
 *     city: firestoreString(),
 *     zip: firestoreString()
 *   }
 * });
 * ```
 */
export declare function firestoreSubObject<T extends object, O extends object = FirestoreModelData<T>>(config: FirestoreSubObjectFieldConfig<T, O>): FirestoreSubObjectFieldMapFunctionsConfig<T, O>;
export interface FirestoreLatLngStringConfig extends DefaultMapConfiguredFirestoreFieldConfig<LatLngString, LatLngString> {
    precision?: LatLngPrecision;
}
/**
 * Creates a field mapping configuration for Firestore latitude/longitude string fields.
 *
 * Stores lat/lng as a single string rather than a lat/lng object or value pair. This is preferred
 * because Firestore cannot efficiently sort/search lat and lng together, making indexing on separate
 * fields useless. As a single string field, it integrates with the {@link LatLngStringRef} interface
 * and can be mapped using `latLngDataPointFunction()`.
 *
 * Applies validation and optional precision rounding on both read and write.
 *
 * @param config - Optional precision and default value configuration
 * @returns A field mapping configuration for LatLngString values
 */
export declare function firestoreLatLngString(config?: FirestoreLatLngStringConfig): FirestoreModelFieldMapFunctionsConfig<`${number},${number}`, `${number},${number}`>;
export type FirestoreTimezoneStringConfig = DefaultMapConfiguredFirestoreFieldConfig<TimezoneString, TimezoneString>;
/**
 * Default configuration for a TimezoneString.
 *
 * The value defaults to UTC.
 *
 * @param config - Optional configuration for the timezone string field, including default value and pre-save default.
 * @returns A configured Firestore field that stores a TimezoneString value.
 */
export declare function firestoreTimezoneString(config?: FirestoreTimezoneStringConfig): FirestoreModelFieldMapFunctionsConfig<string, string>;
export declare const DEFAULT_WEBSITE_LINK: WebsiteLink;
export declare const assignWebsiteLinkFunction: import("@dereekb/util").AssignValuesToPOJOFunction<WebsiteLink>;
export declare const firestoreWebsiteLinkAssignFn: MapFunction<WebsiteLink, WebsiteLink>;
/**
 * Creates a field mapping configuration for Firestore website link fields.
 *
 * @returns A field mapping configuration for website link values
 */
export declare function firestoreWebsiteLink(): FirestoreModelFieldMapFunctionsConfig<WebsiteLink, WebsiteLink>;
/**
 * Creates a field mapping configuration for Firestore arrays of WebsiteLink values.
 *
 * @returns A field mapping configuration for WebsiteLink array values
 */
export declare function firestoreWebsiteLinkArray(): FirestoreModelFieldMapFunctionsConfig<WebsiteLink[], WebsiteLink[]>;
export declare const DEFAULT_FIRESTORE_WEBSITE_FILE_LINK_VALUE: WebsiteFileLink;
export declare const assignWebsiteFileLinkFunction: import("@dereekb/util").AssignValuesToPOJOFunction<WebsiteFileLink>;
export declare const firestoreWebsiteFileLinkAssignFn: MapFunction<WebsiteFileLink, WebsiteFileLink>;
/**
 * Creates a field mapping configuration for Firestore website file link fields.
 *
 * @returns A field mapping configuration for website file link values
 */
export declare function firestoreWebsiteFileLink(): FirestoreModelFieldMapFunctionsConfig<WebsiteFileLink, WebsiteFileLink>;
/**
 * Stores the array of WebsiteFileLink values as an array of objects.
 *
 * @returns A field mapping configuration for WebsiteFileLink array values stored as objects
 */
export declare function firestoreWebsiteFileLinkObjectArray(): FirestoreModelFieldMapFunctionsConfig<WebsiteFileLink[], WebsiteFileLink[]>;
/**
 * Stores the array of WebsiteFileLink values as an array of EncodedWebsiteFileLink values.
 *
 * @returns A field mapping configuration for WebsiteFileLink array values stored in encoded form
 */
export declare function firestoreWebsiteFileLinkEncodedArray(): FirestoreModelFieldMapFunctionsConfig<WebsiteFileLink[], string[]>;
export declare const DEFAULT_DATE_CELL_RANGE_VALUE: DateCellRange;
export declare const assignDateCellRangeFunction: import("@dereekb/util").AssignValuesToPOJOFunction<DateCellRange>;
export declare const firestoreDateCellRangeAssignFn: MapFunction<DateCellRange, DateCellRange>;
/**
 * Creates a field mapping configuration for Firestore date cell range fields.
 *
 * @returns A field mapping configuration for date cell range values
 */
export declare function firestoreDateCellRange(): FirestoreModelFieldMapFunctionsConfig<DateCellRange, DateCellRange>;
/**
 * Creates a field mapping configuration for Firestore arrays of DateCellRange values.
 *
 * @param sort - Whether to sort the array by index number; defaults to true
 * @returns A field mapping configuration for DateCellRange array values
 */
export declare function firestoreDateCellRangeArray(sort?: boolean): FirestoreModelFieldMapFunctionsConfig<DateCellRange[], DateCellRange[]>;
export declare const DEFAULT_FIRESTORE_DATE_CELL_SCHEDULE_VALUE: DateCellSchedule;
export declare const assignDateCellScheduleFunction: import("@dereekb/util").AssignValuesToPOJOFunction<DateCellSchedule>;
export declare const firestoreDateCellScheduleAssignFn: MapFunction<DateCellSchedule, DateCellSchedule>;
/**
 * Creates a field mapping configuration for Firestore date cell schedule fields.
 *
 * @returns A field mapping configuration for date cell schedule values
 */
export declare function firestoreDateCellSchedule(): FirestoreModelFieldMapFunctionsConfig<DateCellSchedule, DateCellSchedule>;
export declare const DEFAULT_FIRESTORE_UNITED_STATES_ADDRESS_VALUE: UnitedStatesAddress;
/**
 * Function to assign values to a UnitedStatesAddress object while filtering specific keys and empty values.
 */
export declare const assignUnitedStatesAddressFunction: import("@dereekb/util").AssignValuesToPOJOFunction<UnitedStatesAddress>;
/**
 * Function to assign values from an input UnitedStatesAddress to a default UnitedStatesAddress.
 *
 * @param input - The source UnitedStatesAddress to copy values from
 * @returns A new UnitedStatesAddress with values assigned from the input
 */
export declare const firestoreUnitedStatesAddressAssignFn: MapFunction<UnitedStatesAddress, UnitedStatesAddress>;
/**
 * Creates a field mapping configuration for Firestore United States address fields.
 *
 * @returns A field mapping configuration for United States address values
 */
export declare function firestoreUnitedStatesAddress(): FirestoreModelFieldMapFunctionsConfig<UnitedStatesAddress, UnitedStatesAddress>;
/**
 * Creates a field mapping configuration for optional Firestore United States address fields.
 *
 * @returns A field mapping configuration for optional United States address values
 */
export declare function optionalFirestoreUnitedStatesAddress(): FirestoreModelFieldMapFunctionsConfig<Maybe<UnitedStatesAddress>, Maybe<UnitedStatesAddress>>;
export declare const MIN_FIRESTORE_MAP_ZOOM_LEVEL_VALUE: ZoomLevel;
export declare const MAX_FIRESTORE_MAP_ZOOM_LEVEL_VALUE: ZoomLevel;
/**
 * Field mapping configuration for Firestore map zoom level fields.
 *
 * Convenience function for firestoreNumber() for storing an integer ZoomLevel value.
 */
export declare const firestoreMapZoomLevel: FirestoreModelFieldMapFunctionsConfig<number, number>;
/**
 * Configuration for a Firestore field that stores a set of numbers as a bitwise-encoded value.
 *
 * @template D - Type of number elements in the set (defaults to number)
 */
export interface FirestoreBitwiseSetConfig<D extends number = number> extends DefaultMapConfiguredFirestoreFieldConfig<Set<D>, BitwiseEncodedSet> {
    /**
     * Maximum index value to support in the bitwise encoding
     */
    readonly maxIndex?: number;
}
/**
 * Creates a field mapping configuration for Firestore fields that store sets of numbers as bitwise-encoded values.
 *
 * @template D - Type of number elements in the set (defaults to number)
 * @param config - Configuration for the bitwise set field
 * @returns A field mapping configuration for bitwise-encoded set values
 */
export declare function firestoreBitwiseSet<D extends number = number>(config: FirestoreBitwiseSetConfig<D>): FirestoreModelFieldMapFunctionsConfig<Set<D>, number>;
/**
 * Configuration for a Firestore field that maps objects with bitwise-encoded set values.
 *
 * @template D - Type of number elements in the sets (defaults to number)
 * @template K - Type of keys in the object (string)
 */
export interface FirestoreBitwiseSetMapConfig<D extends number = number, K extends string = string> extends Omit<FirestoreEncodedObjectMapFieldConfig<Set<D>, BitwiseEncodedSet, K>, 'encoder' | 'decoder'> {
    /**
     * Maximum index value to support in the bitwise encoding
     */
    readonly maxIndex?: number;
}
/**
 * Creates a field mapping configuration for Firestore fields that map objects with bitwise-encoded set values.
 *
 * @template D - Type of number elements in the sets (defaults to number)
 * @template K - Type of keys in the object (string)
 * @param config - Configuration for the bitwise set map field
 * @returns A field mapping configuration for object maps with bitwise-encoded set values
 */
export declare function firestoreBitwiseSetMap<D extends number = number, K extends string = string>(config: FirestoreBitwiseSetMapConfig<D, K>): FirestoreModelFieldMapFunctionsConfig<FirestoreEncodedObjectMapFieldValueType<Set<D>, K>, FirestoreMapFieldType<number, K>>;
/**
 * Configuration for a Firestore field that maps objects with bitwise-encoded object values.
 *
 * @template T - Type of object values in the map
 * @template K - Type of keys in the object (string)
 */
export interface FirestoreBitwiseObjectMapConfig<T extends object, K extends string = string> extends Omit<FirestoreEncodedObjectMapFieldConfig<T, BitwiseEncodedSet, K>, 'encoder' | 'decoder'> {
    /**
     * Function that handles both encoding and decoding of object values to/from bitwise values
     */
    readonly dencoder: BitwiseObjectDencoder<T>;
}
/**
 * Creates a field mapping configuration for Firestore fields that map objects with bitwise-encoded object values.
 *
 * @template T - Type of object values in the map
 * @template K - Type of keys in the object (string)
 * @param config - Configuration for the bitwise object map field
 * @returns A field mapping configuration for object maps with bitwise-encoded object values
 */
export declare function firestoreBitwiseObjectMap<T extends object, K extends string = string>(config: FirestoreBitwiseObjectMapConfig<T, K>): FirestoreModelFieldMapFunctionsConfig<FirestoreEncodedObjectMapFieldValueType<T, K>, FirestoreMapFieldType<number, K>>;