zod-firebase-admin/lib/index.d.cts

zod firebase-admin schema

import { CollectionGroup, CollectionReference, DocumentData, DocumentReference, DocumentSnapshot, FieldPath, Filter, Firestore, FirestoreDataConverter, OrderByDirection, PartialWithFieldValue, Precondition, Query, QueryDocumentSnapshot, QuerySnapshot, SetOptions, Timestamp, UpdateData, WhereFilterOp, WithFieldValue, WriteResult, getFirestore } from "firebase-admin/firestore";
import { ConditionalKeys, ConditionalPick, EmptyObject, Except, ReadonlyDeep } from "type-fest";
import * as z from "zod";
import * as z3 from "zod/v3";
import * as z4 from "zod/v4/core";

//#region src/zod-converters/firestore-omit-meta-data-converter.d.ts
type WithFieldValueAndMetadata<T extends DocumentData = DocumentData> = WithFieldValue<T> & {
  readonly _id?: string;
  readonly _createTime?: Timestamp;
  readonly _updateTime?: Timestamp;
  readonly _readTime?: Timestamp;
};
declare const firestoreOmitMetaDataConverter: <AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData>() => FirestoreDataConverter<AppModelType, DbModelType>;
//#endregion
//#region src/zod-converters/types.d.ts
type ZodSimpleDocumentData<Output extends DocumentData = DocumentData, Input extends DocumentData = Output> = z.ZodType<Output, Input>;
type ZodTypeDocumentData<Output extends DocumentData = DocumentData, Input extends DocumentData = Output> = ZodSimpleDocumentData<Output, Input> | z.ZodUnion<readonly [ZodSimpleDocumentData<Output, Input>, ...Array<ZodSimpleDocumentData<Output, Input>>]>;
type DocumentInput<Z$1 extends ZodTypeDocumentData = ZodTypeDocumentData> = z.input<Z$1>;
interface MetaOutputOptions {
  readonly _id?: boolean;
  readonly _createTime?: true;
  readonly _updateTime?: true;
  readonly _readTime?: true;
  readonly readonly?: true;
}
type MetaOutput<TOptions extends MetaOutputOptions> = (TOptions extends {
  _id: false;
} ? EmptyObject : {
  readonly _id: string;
}) & (TOptions extends {
  _createTime: true;
} ? {
  readonly _createTime: Timestamp;
} : EmptyObject) & (TOptions extends {
  _updateTime: true;
} ? {
  readonly _updateTime: Timestamp;
} : EmptyObject) & (TOptions extends {
  _readTime: true;
} ? {
  readonly _readTime: Timestamp;
} : EmptyObject);
type DocumentOutput<Z$1 extends ZodTypeDocumentData, TOptions extends MetaOutputOptions = MetaOutputOptions> = (TOptions extends {
  readonly: true;
} ? ReadonlyDeep<z.output<Z$1>> : z.output<Z$1>) & MetaOutput<TOptions>;
type ReadonlyDocumentOutput<Z$1 extends ZodTypeDocumentData, TOptions extends MetaOutputOptions = MetaOutputOptions> = ReadonlyDeep<z.output<Z$1>> & MetaOutput<TOptions>;
type ZodDocumentReference<Z$1 extends ZodTypeDocumentData, TOptions extends MetaOutputOptions = MetaOutputOptions, AppModelType extends DocumentOutput<Z$1, TOptions> = DocumentOutput<Z$1, TOptions>, DbModelType extends DocumentData = DocumentInput<Z$1>> = DocumentReference<AppModelType, DbModelType>;
type ZodDocumentSnapshot<Z$1 extends ZodTypeDocumentData, TOptions extends MetaOutputOptions = MetaOutputOptions, AppModelType extends DocumentOutput<Z$1, TOptions> = DocumentOutput<Z$1, TOptions>, DbModelType extends DocumentData = DocumentInput<Z$1>> = DocumentSnapshot<AppModelType, DbModelType>;
type ZodCollectionReference<Z$1 extends ZodTypeDocumentData, TOptions extends MetaOutputOptions = MetaOutputOptions, AppModelType extends DocumentOutput<Z$1, TOptions> = DocumentOutput<Z$1, TOptions>, DbModelType extends DocumentData = DocumentInput<Z$1>> = CollectionReference<AppModelType, DbModelType>;
type ZodCollectionGroup<Z$1 extends ZodTypeDocumentData, TOptions extends MetaOutputOptions = MetaOutputOptions, AppModelType extends DocumentOutput<Z$1, TOptions> = DocumentOutput<Z$1, TOptions>, DbModelType extends DocumentData = DocumentInput<Z$1>> = CollectionGroup<AppModelType, DbModelType>;
type ZodQuery<Z$1 extends ZodTypeDocumentData, TOptions extends MetaOutputOptions = MetaOutputOptions, AppModelType extends DocumentOutput<Z$1, TOptions> = DocumentOutput<Z$1, TOptions>, DbModelType extends DocumentData = DocumentInput<Z$1>> = Query<AppModelType, DbModelType>;
type ZodQuerySnapshot<Z$1 extends ZodTypeDocumentData, TOptions extends MetaOutputOptions = MetaOutputOptions, AppModelType extends DocumentOutput<Z$1, TOptions> = DocumentOutput<Z$1, TOptions>, DbModelType extends DocumentData = DocumentInput<Z$1>> = QuerySnapshot<AppModelType, DbModelType>;
//#endregion
//#region src/zod-converters/zod-error-handler.d.ts
type ZodErrorHandler = <T extends DocumentData = DocumentData>(zodError: z4.$ZodError<T> | z3.ZodError<T>, snapshot: QueryDocumentSnapshot) => Error;
//#endregion
//#region src/zod-converters/firestore-zod-data-converter.d.ts
interface FirestoreZodDataConverterOptions {
  readonly includeDocumentIdForZod?: boolean;
  readonly zodErrorHandler?: ZodErrorHandler;
  readonly snapshotDataConverter?: (snapshot: QueryDocumentSnapshot) => DocumentData;
}
declare const firestoreZodDataConverter: <Z$1 extends ZodTypeDocumentData, TOptions extends MetaOutputOptions, AppModelType extends DocumentOutput<Z$1, TOptions> = DocumentOutput<Z$1, TOptions>, DbModelType extends DocumentData = DocumentInput<Z$1>>(zod: Z$1, outputOptions?: TOptions, options?: FirestoreZodDataConverterOptions) => FirestoreDataConverter<AppModelType, DbModelType>;
//#endregion
//#region src/zod-converters/firestore-zod-options.d.ts
type FirestoreZodOptions = FirestoreZodDataConverterOptions & {
  readonly firestore?: Firestore;
};
//#endregion
//#region src/schema/types/schema.d.ts
type CollectionSchema<Z$1 extends ZodTypeDocumentData = ZodTypeDocumentData, TSubCollectionsSchema extends Schema = EmptyObject> = {
  readonly zod: Z$1;
  readonly singleDocumentKey?: string;
  readonly includeDocumentIdForZod?: true;
  readonly readonlyDocuments?: true;
} & TSubCollectionsSchema;
type Schema = Record<string, CollectionSchema>;
//#endregion
//#region src/schema/types/doc.d.ts
type CollectionSchemaZod<TCollectionSchema> = TCollectionSchema extends CollectionSchema<infer Z extends ZodTypeDocumentData> ? Z : never;
type SchemaDocumentInput<TCollectionSchema extends CollectionSchema> = z.input<CollectionSchemaZod<TCollectionSchema>> | ReadonlyDeep<z.input<CollectionSchemaZod<TCollectionSchema>>>;
type SchemaDocumentOutput<TCollectionSchema extends CollectionSchema, TOptions extends MetaOutputOptions = MetaOutputOptions> = TCollectionSchema extends {
  readonlyDocuments: true;
} ? ReadonlyDocumentOutput<CollectionSchemaZod<TCollectionSchema>, TOptions> : DocumentOutput<CollectionSchemaZod<TCollectionSchema>, TOptions>;
//#endregion
//#region src/query/query-specification.d.ts
type WhereTuple = [FieldPath | string, WhereFilterOp, any];
type OrderByTuple = [FieldPath | string, OrderByDirection] | [FieldPath | string];
interface QuerySpecification<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData> {
  name: string;
  where?: WhereTuple[] | Filter;
  orderBy?: OrderByTuple[];
  limit?: number;
  limitToLast?: number;
  offset?: number;
  startAt?: DocumentSnapshot<AppModelType, DbModelType> | unknown[];
  startAfter?: DocumentSnapshot<AppModelType, DbModelType> | unknown[];
  endAt?: DocumentSnapshot<AppModelType, DbModelType> | unknown[];
  endBefore?: DocumentSnapshot<AppModelType, DbModelType> | unknown[];
}
declare const applyQuerySpecification: <AppModelType, DbModelType extends DocumentData = DocumentData>(query: Query<AppModelType, DbModelType>, {
  where,
  orderBy,
  limit,
  limitToLast,
  offset,
  startAt,
  startAfter,
  endAt,
  endBefore
}: QuerySpecification<AppModelType, DbModelType>) => Query<AppModelType, DbModelType>;
//#endregion
//#region src/query/query-helper.d.ts
interface QueryHelper<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData> {
  prepare(query: QuerySpecification): Query<AppModelType, DbModelType>;
  query(query: QuerySpecification): Promise<QuerySnapshot<AppModelType, DbModelType>>;
  count(query: QuerySpecification): Promise<number>;
  findMany(query: QuerySpecification): Promise<AppModelType[]>;
  findUnique(query: QuerySpecification): Promise<AppModelType | null>;
  findUniqueOrThrow(query: QuerySpecification): Promise<AppModelType>;
  findFirst(query: QuerySpecification): Promise<AppModelType | null>;
  findFirstOrThrow(query: QuerySpecification): Promise<AppModelType>;
}
declare const queryHelper: <AppModelType, DbModelType extends DocumentData>(queryFactory: (querySpecification: QuerySpecification) => Query<AppModelType, DbModelType>) => QueryHelper<AppModelType, DbModelType>;
//#endregion
//#region src/schema/types/query.d.ts
type SchemaQuery<TCollectionSchema extends CollectionSchema, TOptions extends MetaOutputOptions = MetaOutputOptions> = Query<SchemaDocumentOutput<TCollectionSchema, TOptions>, SchemaDocumentInput<TCollectionSchema>>;
type SchemaQuerySnapshot<TCollectionSchema extends CollectionSchema, TOptions extends MetaOutputOptions = MetaOutputOptions> = QuerySnapshot<SchemaDocumentOutput<TCollectionSchema, TOptions>, SchemaDocumentInput<TCollectionSchema>>;
type SchemaDocumentSnapshot<TCollectionSchema extends CollectionSchema, TOptions extends MetaOutputOptions = MetaOutputOptions> = DocumentSnapshot<SchemaDocumentOutput<TCollectionSchema, TOptions>, SchemaDocumentInput<TCollectionSchema>>;
type SchemaQueryDocumentSnapshot<TCollectionSchema extends CollectionSchema, TOptions extends MetaOutputOptions = MetaOutputOptions> = QueryDocumentSnapshot<SchemaDocumentOutput<TCollectionSchema, TOptions>, SchemaDocumentInput<TCollectionSchema>>;
type SchemaQuerySpecification<TCollectionSchema extends CollectionSchema, TOptions extends MetaOutputOptions = MetaOutputOptions> = QuerySpecification<SchemaDocumentOutput<TCollectionSchema, TOptions>, SchemaDocumentInput<TCollectionSchema>>;
interface SchemaFirestoreQueryFactory<TCollectionSchema extends CollectionSchema> {
  readonly collectionName: string;
  prepare<TOptions extends MetaOutputOptions>(query: SchemaQuerySpecification<TCollectionSchema, TOptions>, options?: TOptions): SchemaQuery<TCollectionSchema, TOptions>;
  query<TOptions extends MetaOutputOptions>(query: SchemaQuerySpecification<TCollectionSchema, TOptions>, options?: TOptions): Promise<SchemaQuerySnapshot<TCollectionSchema, TOptions>>;
  count(query: SchemaQuerySpecification<TCollectionSchema>): Promise<number>;
  findMany<TOptions extends MetaOutputOptions>(query: SchemaQuerySpecification<TCollectionSchema, TOptions>, options?: TOptions): Promise<Array<SchemaDocumentOutput<TCollectionSchema, TOptions>>>;
  findUnique<TOptions extends MetaOutputOptions>(query: SchemaQuerySpecification<TCollectionSchema, TOptions>, options?: TOptions): Promise<SchemaDocumentOutput<TCollectionSchema, TOptions> | null>;
  findUniqueOrThrow<TOptions extends MetaOutputOptions>(query: SchemaQuerySpecification<TCollectionSchema, TOptions>, options?: TOptions): Promise<SchemaDocumentOutput<TCollectionSchema, TOptions>>;
  findFirst<TOptions extends MetaOutputOptions>(query: SchemaQuerySpecification<TCollectionSchema, TOptions>, options?: TOptions): Promise<SchemaDocumentOutput<TCollectionSchema, TOptions> | null>;
  findFirstOrThrow<TOptions extends MetaOutputOptions>(query: SchemaQuerySpecification<TCollectionSchema, TOptions>, options?: TOptions): Promise<SchemaDocumentOutput<TCollectionSchema, TOptions>>;
}
//#endregion
//#region src/schema/types/read.d.ts
type SchemaReadCollectionReference<TCollectionSchema extends CollectionSchema, TOptions extends MetaOutputOptions = MetaOutputOptions> = CollectionReference<SchemaDocumentOutput<TCollectionSchema, TOptions>, SchemaDocumentInput<TCollectionSchema>>;
type SchemaReadDocumentReference<TCollectionSchema extends CollectionSchema, TOptions extends MetaOutputOptions = MetaOutputOptions> = DocumentReference<SchemaDocumentOutput<TCollectionSchema, TOptions>, SchemaDocumentInput<TCollectionSchema>>;
type SchemaReadCollectionGroup<TCollectionSchema extends CollectionSchema, TOptions extends MetaOutputOptions = MetaOutputOptions> = Query<SchemaDocumentOutput<TCollectionSchema, TOptions>, SchemaDocumentInput<TCollectionSchema>>;
interface SchemaFirestoreReadFactory<TCollectionSchema extends CollectionSchema> {
  collection<TOptions extends MetaOutputOptions>(this: void, options?: TOptions): SchemaReadCollectionReference<TCollectionSchema, TOptions>;
  doc<TOptions extends MetaOutputOptions>(this: void, id: string, options?: TOptions): SchemaReadDocumentReference<TCollectionSchema, TOptions>;
  collectionGroup<TOptions extends MetaOutputOptions>(this: void, options?: TOptions): SchemaReadCollectionGroup<TCollectionSchema, TOptions>;
}
//#endregion
//#region src/schema/types/write.d.ts
type SchemaWriteCollectionReference<TCollectionSchema extends CollectionSchema> = CollectionReference<SchemaDocumentInput<TCollectionSchema>, SchemaDocumentInput<TCollectionSchema>>;
type SchemaWriteDocumentReference<TCollectionSchema extends CollectionSchema> = DocumentReference<SchemaDocumentInput<TCollectionSchema>, SchemaDocumentInput<TCollectionSchema>>;
interface SchemaFirestoreWriteFactory<TCollectionSchema extends CollectionSchema> {
  collection(this: void): SchemaWriteCollectionReference<TCollectionSchema>;
  doc(this: void, id: string): SchemaWriteDocumentReference<TCollectionSchema>;
}
//#endregion
//#region src/schema/types/factory.d.ts
interface SchemaFirestoreFactory<TCollectionSchema extends CollectionSchema> extends SchemaFirestoreQueryFactory<TCollectionSchema> {
  readonly read: SchemaFirestoreReadFactory<TCollectionSchema>;
  readonly write: SchemaFirestoreWriteFactory<TCollectionSchema>;
}
//#endregion
//#region src/schema/types/factory-options.d.ts
interface FirestoreFactoryOptions {
  readonly getFirestore?: typeof getFirestore;
}
interface FirestoreZodFactoryOptions extends FirestoreFactoryOptions, Except<FirestoreZodDataConverterOptions, 'includeDocumentIdForZod'> {}
//#endregion
//#region src/collection/factory/multi-document-collection-factory.d.ts
type SchemaFallbackValue<TCollectionSchema extends CollectionSchema, TDocumentId extends string = string> = TCollectionSchema extends {
  includeDocumentIdForZod: true;
} ? Except<Extract<SchemaDocumentInput<TCollectionSchema>, {
  _id: TDocumentId;
}>, '_id'> : SchemaDocumentInput<TCollectionSchema>;
type SchemaFallbackOutputDocument<TCollectionSchema extends CollectionSchema, TDocumentId extends string = string> = TCollectionSchema extends {
  includeDocumentIdForZod: true;
} ? Except<Extract<SchemaDocumentOutput<TCollectionSchema>, {
  _id: TDocumentId;
}>, '_id'> : SchemaDocumentOutput<TCollectionSchema>;
interface MultiDocumentCollectionFactory<TCollectionSchema extends CollectionSchema> extends SchemaFirestoreFactory<TCollectionSchema> {
  findById<TOptions extends MetaOutputOptions>(this: void, id: string, options?: TOptions): Promise<SchemaDocumentOutput<TCollectionSchema, TOptions> | undefined>;
  findByIdOrThrow<TOptions extends MetaOutputOptions>(this: void, id: string, options?: TOptions): Promise<SchemaDocumentOutput<TCollectionSchema, TOptions>>;
  findByIdWithFallback<TDocumentId extends string>(this: void, id: TDocumentId, fallback: SchemaFallbackValue<TCollectionSchema, TDocumentId>): Promise<SchemaFallbackOutputDocument<TCollectionSchema, TDocumentId>>;
  add(this: void, data: WithFieldValue<SchemaDocumentInput<TCollectionSchema>>): Promise<SchemaWriteDocumentReference<TCollectionSchema>>;
  create(this: void, id: string, data: WithFieldValue<SchemaDocumentInput<TCollectionSchema>>): Promise<WriteResult>;
  set(this: void, id: string, data: WithFieldValue<SchemaDocumentInput<TCollectionSchema>>): Promise<WriteResult>;
  set(this: void, id: string, data: PartialWithFieldValue<SchemaDocumentInput<TCollectionSchema>>, options: SetOptions): Promise<WriteResult>;
  update(this: void, id: string, data: UpdateData<SchemaDocumentInput<TCollectionSchema>>, precondition?: Precondition): Promise<WriteResult>;
  delete(this: void, id: string, precondition?: Precondition): Promise<WriteResult>;
}
declare const multiDocumentCollectionFactory: <TCollectionSchema extends CollectionSchema>(firestoreFactory: SchemaFirestoreFactory<TCollectionSchema>, schema: TCollectionSchema) => MultiDocumentCollectionFactory<TCollectionSchema>;
//#endregion
//#region src/collection/factory/single-document-collection-factory.d.ts
interface SingleDocumentCollectionFactory<TCollectionSchema extends CollectionSchema> {
  readonly singleDocumentKey: string;
  readonly read: Except<SchemaFirestoreReadFactory<TCollectionSchema>, 'doc'> & {
    doc<TOptions extends MetaOutputOptions>(this: void, options?: TOptions): SchemaReadDocumentReference<TCollectionSchema, TOptions>;
  };
  readonly write: Except<SchemaFirestoreWriteFactory<TCollectionSchema>, 'doc'> & {
    doc(this: void): SchemaWriteDocumentReference<TCollectionSchema>;
  };
  find<TOptions extends MetaOutputOptions>(this: void, options?: TOptions): Promise<SchemaDocumentOutput<TCollectionSchema, TOptions> | undefined>;
  findOrThrow<TOptions extends MetaOutputOptions>(this: void, options?: TOptions): Promise<SchemaDocumentOutput<TCollectionSchema, TOptions>>;
  findWithFallback(this: void, fallback: SchemaFallbackValue<TCollectionSchema>): Promise<SchemaFallbackOutputDocument<TCollectionSchema>>;
  create(this: void, data: WithFieldValue<SchemaDocumentInput<TCollectionSchema>>): Promise<WriteResult>;
  set(this: void, data: WithFieldValue<SchemaDocumentInput<TCollectionSchema>>): Promise<WriteResult>;
  set(this: void, data: PartialWithFieldValue<SchemaDocumentInput<TCollectionSchema>>, options: SetOptions): Promise<WriteResult>;
  update(this: void, data: UpdateData<SchemaDocumentInput<TCollectionSchema>>, precondition?: Precondition): Promise<WriteResult>;
  delete(this: void, precondition?: Precondition): Promise<WriteResult>;
}
declare const singleDocumentCollectionFactory: <TCollectionSchema extends CollectionSchema>(firestoreFactory: SchemaFirestoreFactory<TCollectionSchema>, schema: TCollectionSchema, singleDocumentKey: string) => SingleDocumentCollectionFactory<TCollectionSchema>;
//#endregion
//#region src/collection/factory/types.d.ts
type SingleOrMultiDocumentCollectionFactory<TCollectionSchema extends CollectionSchema> = TCollectionSchema extends {
  singleDocumentKey: string;
} ? SingleDocumentCollectionFactory<TCollectionSchema> : MultiDocumentCollectionFactory<TCollectionSchema>;
type CollectionFactory<TCollectionName extends string, TCollectionSchema extends CollectionSchema> = SingleOrMultiDocumentCollectionFactory<TCollectionSchema> & TCollectionSchema & {
  readonly collectionName: TCollectionName;
  readonly collectionPath: string;
};
//#endregion
//#region src/collection/types.d.ts
type Collections<TSchema extends object> = { [CollectionName in ConditionalKeys<TSchema, CollectionSchema>]: TSchema[CollectionName] & Collection<CollectionName, TSchema[CollectionName]> };
type SubCollections<TSchema extends object> = { [CollectionName in ConditionalKeys<TSchema, CollectionSchema>]: TSchema[CollectionName] & SubCollection<CollectionName, TSchema[CollectionName]> };
type SubCollectionsAccessor<TSchema extends Schema> = (documentId: string) => Collections<TSchema>;
type Collection<TCollectionName extends string, TCollectionSchema extends CollectionSchema> = CollectionFactory<TCollectionName, TCollectionSchema> & SubCollections<TCollectionSchema> & SubCollectionsAccessor<ConditionalPick<TCollectionSchema, CollectionSchema>>;
type SubCollection<TCollectionName extends string, TCollectionSchema extends CollectionSchema> = TCollectionSchema & {
  readonly collectionName: TCollectionName;
  readonly group: SchemaFirestoreQueryFactory<TCollectionSchema>;
} & SubCollections<TCollectionSchema>;
//#endregion
//#region src/collection-builder.d.ts
/**
 * Build collections from a schema
 * @param schema
 * @param options
 */
declare const collectionsBuilder: <TSchema extends Schema>(schema: TSchema, options?: FirestoreZodFactoryOptions) => Collections<TSchema>;
//#endregion
//#region src/primitive/firestore-collection-path.d.ts
type CollectionPath = [string] | [string, string, string];
declare const firestoreCollectionPath: (path: CollectionPath | string) => string;
//#endregion
//#region src/primitive/firestore-collection.d.ts
declare const firestoreCollection: <AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(collectionPath: CollectionPath | string, firestore?: FirebaseFirestore.Firestore) => CollectionReference<AppModelType, DbModelType>;
//#endregion
//#region src/primitive/firestore-collection-group.d.ts
declare const firestoreCollectionGroup: <AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(collectionId: string, firestore?: FirebaseFirestore.Firestore) => CollectionGroup<AppModelType, DbModelType>;
//#endregion
//#region src/primitive/firestore-document.d.ts
declare const firestoreDocument: <AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(collectionPath: CollectionPath | string, documentId: string, firestore?: FirebaseFirestore.Firestore) => DocumentReference<AppModelType, DbModelType>;
//#endregion
//#region src/primitive/firestore-document-path.d.ts
declare const firestoreDocumentPath: (collectionPath: CollectionPath | string, documentId: string) => string;
//#endregion
export { Collection, CollectionFactory, CollectionPath, CollectionSchema, Collections, DocumentInput, DocumentOutput, FirestoreFactoryOptions, FirestoreZodDataConverterOptions, FirestoreZodFactoryOptions, FirestoreZodOptions, MetaOutput, MetaOutputOptions, MultiDocumentCollectionFactory, QueryHelper, QuerySpecification, ReadonlyDocumentOutput, Schema, SchemaDocumentInput, SchemaDocumentOutput, SchemaDocumentSnapshot, SchemaFallbackOutputDocument, SchemaFallbackValue, SchemaFirestoreFactory, SchemaFirestoreQueryFactory, SchemaFirestoreReadFactory, SchemaFirestoreWriteFactory, SchemaQuery, SchemaQueryDocumentSnapshot, SchemaQuerySnapshot, SchemaQuerySpecification, SchemaReadCollectionGroup, SchemaReadCollectionReference, SchemaReadDocumentReference, SchemaWriteCollectionReference, SchemaWriteDocumentReference, SingleDocumentCollectionFactory, SingleOrMultiDocumentCollectionFactory, SubCollection, SubCollections, SubCollectionsAccessor, WithFieldValueAndMetadata, ZodCollectionGroup, ZodCollectionReference, ZodDocumentReference, ZodDocumentSnapshot, ZodErrorHandler, ZodQuery, ZodQuerySnapshot, ZodTypeDocumentData, applyQuerySpecification, collectionsBuilder, firestoreCollection, firestoreCollectionGroup, firestoreCollectionPath, firestoreDocument, firestoreDocumentPath, firestoreOmitMetaDataConverter, firestoreZodDataConverter, multiDocumentCollectionFactory, queryHelper, singleDocumentCollectionFactory };