@visiolab/effect-firebase 0.0.0-stage → 0.3.1

package/dist/firestore/FirestoreSchema.mjs

@@ -0,0 +1,419 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { ArrayOr as ArrayOr$1, ArrayRemove as ArrayRemove$1, ArrayUnion as ArrayUnion$1, DeleteField as DeleteField$1, DeleteFieldOr as DeleteFieldOr$1, DocumentPath as DocumentPath$1, DocumentReference as DocumentReference$1, GeoPoint as GeoPoint$1, Increment as Increment$1, IncrementOr as IncrementOr$1, ServerTimestamp as ServerTimestamp$1, ServerTimestampOr as ServerTimestampOr$1, Timestamp as Timestamp$1 } from "./internal/firestoreSchema.mjs";
+// src/firestore/FirestoreSchema.ts
+var FirestoreSchema_exports = /* @__PURE__ */ __exportAll({
+	ArrayOr: () => ArrayOr,
+	ArrayRemove: () => ArrayRemove,
+	ArrayUnion: () => ArrayUnion,
+	DeleteField: () => DeleteField,
+	DeleteFieldOr: () => DeleteFieldOr,
+	DocumentPath: () => DocumentPath,
+	DocumentReference: () => DocumentReference,
+	GeoPoint: () => GeoPoint,
+	Increment: () => Increment,
+	IncrementOr: () => IncrementOr,
+	ServerTimestamp: () => ServerTimestamp,
+	ServerTimestampOr: () => ServerTimestampOr,
+	Timestamp: () => Timestamp
+});
+/**
+* Schema for a Firestore timestamp, held as the portable
+* {@link Timestamp.Timestamp}.
+*
+* **When to use**
+*
+* Use when a document is read, written back, and has to come out unchanged.
+* Use `Schema.DateTimeUtc` or `Schema.Date` when a millisecond is precise
+* enough and that value is easier to work with: Firestore stores both as a
+* timestamp too, but they drop the digits finer than a millisecond.
+*
+* **Details**
+*
+* It serializes with `Schema.toCodecJson` as `{ seconds, nanoseconds }`, so the
+* same model can be sent over HTTP.
+*
+* @example Storing a timestamp at full precision
+* ```ts
+* import { Schema } from "effect";
+* import { FirestoreSchema } from "@visiolab/effect-firebase/firestore";
+*
+* const Event = Schema.Struct({ at: FirestoreSchema.Timestamp });
+* ```
+*
+* @see {@link FirestoreModel.Timestamp} for a timestamp field the server may also fill in
+* @see {@link ServerTimestampOr} for the write side of such a field
+* @see {@link TimeSchema} for every schema Firestore stores as a timestamp
+*
+* @stability unstable
+* @category schemas
+* @since 0.2.0
+*/
+const Timestamp = Timestamp$1;
+/**
+* Schema for a Firestore geopoint, held as the portable
+* {@link GeoPoint.GeoPoint}.
+*
+* **When to use**
+*
+* Use for a location field. A hand-written struct of `latitude` and
+* `longitude` would be stored as a map; this schema is stored as Firestore's
+* own geopoint.
+*
+* @example Storing a location
+* ```ts
+* import { Schema } from "effect";
+* import { FirestoreSchema } from "@visiolab/effect-firebase/firestore";
+*
+* const Place = Schema.Struct({ name: Schema.String, location: FirestoreSchema.GeoPoint });
+* ```
+*
+* @see {@link GeoPoint.make} for building a geopoint
+*
+* @stability unstable
+* @category schemas
+* @since 0.2.0
+*/
+const GeoPoint = GeoPoint$1;
+/**
+* Schema for an untyped reference to a document, held as the portable
+* {@link DocumentPath.DocumentPath}.
+*
+* **When to use**
+*
+* Use for a reference whose target collection the model does not know. Use
+* {@link DocumentReference} when the field always points into a known
+* collection.
+*
+* **Details**
+*
+* It is stored as the SDK's own reference, built against the database the
+* document is written to.
+*
+* @see {@link DocumentReference} for a reference typed by its collection
+*
+* @stability unstable
+* @category schemas
+* @since 0.2.0
+*/
+const DocumentPath = DocumentPath$1;
+/**
+* Schema for a reference to a document in `collection`, held as a typed
+* {@link Collection.DocumentReference}.
+*
+* **When to use**
+*
+* Use for a field that points to a document in a known collection, so the
+* reference keeps its ids and model typed. For a field that may point into
+* several collections, use a `Schema.Union` of one of these per collection.
+* Use {@link DocumentPath} when the target collection is unknown.
+*
+* **Details**
+*
+* Firestore stores a reference as the document's path alone, so it is written
+* as a {@link DocumentPath.DocumentPath}. Reading it back checks the path
+* against the collection's segments and rebuilds the collection's own
+* reference, equal to one built from `collection`. A path into any other
+* collection, even one with the same last segment, fails to decode.
+* `Schema.is` only accepts references built from `collection`.
+*
+* @example Referencing the author of a post
+* ```ts
+* import { Schema } from "effect";
+* import { Collection, FirestoreModel, FirestoreSchema } from "@visiolab/effect-firebase/firestore";
+*
+* class User extends FirestoreModel.Class<User>("User")({ name: Schema.String }) {}
+* const Users = Collection.make("users", User);
+*
+* class Post extends FirestoreModel.Class<Post>("Post")({
+*   author: FirestoreSchema.DocumentReference(Users),
+* }) {}
+* ```
+*
+* @see {@link DocumentPath} for an untyped reference
+*
+* @stability unstable
+* @category schemas
+* @since 0.2.0
+*/
+const DocumentReference = DocumentReference$1;
+/**
+* Schema that always writes the {@link FieldValue.serverTimestamp} sentinel,
+* and fills it in when the value is constructed.
+*
+* **When to use**
+*
+* Use in a write-only schema for a field that is always the server's time,
+* such as `updatedAt` on every update. Use {@link ServerTimestampOr} when the
+* field may also be written with a time of your own.
+*
+* **Details**
+*
+* It accepts only the sentinel, and its constructor default fills it in, the
+* way `Schema.tag` fills in a tag, so a call site never names the field. A
+* document never holds the sentinel: the field reads back as the timestamp the
+* server wrote, so the read side is a timestamp schema.
+*
+* @example Stamping every update with the server's time
+* ```ts
+* import { Schema } from "effect";
+* import { FirestoreSchema } from "@visiolab/effect-firebase/firestore";
+*
+* const Touch = Schema.Struct({ updatedAt: FirestoreSchema.ServerTimestamp });
+*
+* const update = Touch.make({}); // { updatedAt: FieldValue.serverTimestamp }
+* ```
+*
+* @see {@link ServerTimestampOr} for a field that may also take a time of your own
+* @see {@link FirestoreModel.Timestamp} for the matching model field
+*
+* @stability unstable
+* @category schemas
+* @since 0.2.0
+*/
+const ServerTimestamp = ServerTimestamp$1;
+/**
+* Schema for a timestamp field written either as a time of your own or as
+* {@link FieldValue.serverTimestamp}.
+*
+* **When to use**
+*
+* Use as the write side of a timestamp field when building model variants by
+* hand. Most models use {@link FirestoreModel.Timestamp}, which pairs this with
+* the read side for you.
+*
+* **Details**
+*
+* `schema` is the read side: {@link Timestamp} to keep digits finer than a
+* millisecond, or `Schema.DateTimeUtc` or `Schema.Date` (see
+* {@link TimeSchema}). A read never sees the sentinel, so the read variant
+* uses `schema` alone.
+*
+* @example A timestamp the server may fill in
+* ```ts
+* import { Schema } from "effect";
+* import { FieldValue, FirestoreSchema } from "@visiolab/effect-firebase/firestore";
+*
+* const UpdatedAt = FirestoreSchema.ServerTimestampOr(Schema.DateTimeUtc);
+*
+* Schema.is(UpdatedAt)(FieldValue.serverTimestamp); // true
+* ```
+*
+* @see {@link FirestoreModel.Timestamp} for the model field built on it
+* @see {@link ServerTimestamp} for a field that always writes the sentinel
+* @see {@link FieldValue.serverTimestamp} for the sentinel itself
+*
+* @stability unstable
+* @category schemas
+* @since 0.2.0
+*/
+const ServerTimestampOr = ServerTimestampOr$1;
+/**
+* Schema for the {@link FieldValue.Increment} sentinel, as built by
+* {@link FieldValue.increment} and {@link FieldValue.decrement}.
+*
+* **When to use**
+*
+* Use in a write-only schema for a field that is only ever moved, never set.
+* Use {@link IncrementOr} for a field that may be set outright too.
+*
+* **Details**
+*
+* A document holds the sum the server wrote, so the read side of the same
+* field is a plain number.
+*
+* @see {@link IncrementOr} for a number that may also be set outright
+* @see {@link FirestoreModel.Number} for the matching model field
+*
+* @stability unstable
+* @category schemas
+* @since 0.2.0
+*/
+const Increment = Increment$1;
+/**
+* Schema for a number field written either as a number or as an
+* {@link FieldValue.increment} or {@link FieldValue.decrement}.
+*
+* **When to use**
+*
+* Use as the write side of a counter when building model variants by hand.
+* Most models use {@link FirestoreModel.Number}, which pairs this with the
+* read side for you.
+*
+* **Details**
+*
+* `schema` is the read side and says what the number may be: `Schema.Finite`,
+* `Schema.Int` for whole steps, or either with further checks. It must be
+* stored as a number, since that is what the server adds to. A read never sees
+* the sentinel, so the read variant uses `schema` alone.
+*
+* @example A counter the server may move
+* ```ts
+* import { Schema } from "effect";
+* import { FieldValue, FirestoreSchema } from "@visiolab/effect-firebase/firestore";
+*
+* const Visits = FirestoreSchema.IncrementOr(Schema.Int);
+*
+* Schema.is(Visits)(FieldValue.increment(1)); // true
+* ```
+*
+* @see {@link FirestoreModel.Number} for the model field built on it
+* @see {@link Increment} for a field that is only ever moved
+* @see {@link FieldValue.increment} for the sentinel itself
+*
+* @stability unstable
+* @category schemas
+* @since 0.2.0
+*/
+const IncrementOr = IncrementOr$1;
+/**
+* Schema for the {@link FieldValue.deleteField} sentinel.
+*
+* **When to use**
+*
+* Use when building an update schema by hand. Most models get it through
+* {@link DeleteFieldOr}, or through {@link FirestoreModel.Optional}.
+*
+* **Details**
+*
+* Unlike {@link ServerTimestamp}, it has no constructor default: a field is
+* only removed when you ask for it. A removed field is not there to read, so
+* the read side of the same field is an optional key.
+*
+* @see {@link DeleteFieldOr} for a field an update may write or remove
+* @see {@link FirestoreModel.Optional} for the matching model field
+*
+* @stability unstable
+* @category schemas
+* @since 0.2.0
+*/
+const DeleteField = DeleteField$1;
+/**
+* Schema for a field an update either writes or removes with
+* {@link FieldValue.deleteField}.
+*
+* **When to use**
+*
+* Use as the update side of an optional field when building model variants by
+* hand. Most models use {@link FirestoreModel.Optional}, which does this for
+* you.
+*
+* **Details**
+*
+* `schema` is what the field holds while it is there. Only an update accepts
+* it: a read never holds the sentinel, and Firestore refuses it in a document
+* written whole.
+*
+* The sentinel is tried first, since a schema that accepts any object, such
+* as a struct whose keys are all optional, would accept it too and strip it to
+* `{}`.
+*
+* @example An optional field an update may remove
+* ```ts
+* import { Schema } from "effect";
+* import { FieldValue, FirestoreSchema } from "@visiolab/effect-firebase/firestore";
+*
+* const Nickname = FirestoreSchema.DeleteFieldOr(Schema.String);
+*
+* Schema.is(Nickname)(FieldValue.deleteField); // true
+* ```
+*
+* @see {@link FirestoreModel.Optional} for the model field built on it
+* @see {@link FieldValue.deleteField} for the sentinel itself
+*
+* @stability unstable
+* @category schemas
+* @since 0.2.0
+*/
+const DeleteFieldOr = DeleteFieldOr$1;
+/**
+* Schema for the {@link FieldValue.arrayUnion} sentinel, with each element
+* encoded through `item`.
+*
+* **When to use**
+*
+* Use when building an update schema by hand. Most models get it through
+* {@link ArrayOr}, or through {@link FirestoreModel.Array}.
+*
+* **Details**
+*
+* Each element is encoded through `item`, then stored the way
+* {@link FirestoreValue.toCodecFirestore} stores `item`, so a `DateTimeUtc`
+* among them is stored as a timestamp, and an element `item` rejects is
+* rejected here too.
+*
+* Firestore requires two things of `item`: it is not an array itself, since
+* arrays may not nest, and it does not write a sentinel, since one may not sit
+* inside an array.
+*
+* A document holds the array the server wrote, so the read side of the same
+* field is the array.
+*
+* @see {@link ArrayRemove} for removing elements
+* @see {@link ArrayOr} for an array field written whole, grown or shrunk
+*
+* @stability unstable
+* @category schemas
+* @since 0.2.0
+*/
+const ArrayUnion = ArrayUnion$1;
+/**
+* Schema for the {@link FieldValue.arrayRemove} sentinel, with each element
+* encoded through `item`.
+*
+* **When to use**
+*
+* Use when building an update schema by hand. Most models get it through
+* {@link ArrayOr}, or through {@link FirestoreModel.Array}.
+*
+* **Details**
+*
+* Each element is encoded through `item`, as for {@link ArrayUnion}. Encode
+* through the same schema the array was written with: the server only removes
+* elements that match exactly.
+*
+* @see {@link ArrayUnion} for adding elements
+* @see {@link ArrayOr} for an array field written whole, grown or shrunk
+*
+* @stability unstable
+* @category schemas
+* @since 0.2.0
+*/
+const ArrayRemove = ArrayRemove$1;
+/**
+* Schema for an array field written whole, or grown or shrunk by the server
+* with {@link FieldValue.arrayUnion} and {@link FieldValue.arrayRemove}.
+*
+* **When to use**
+*
+* Use as the update side of an array of `item` when building model variants by
+* hand, against a read of `Schema.Array(item)`. Most models use
+* {@link FirestoreModel.Array}, which pairs the two for you.
+*
+* **Details**
+*
+* Writing the array whole replaces what the server holds, so a client that
+* read it, added an element and wrote it back loses whatever another client
+* added in between. Growing or shrinking it does not. A read never sees the
+* sentinels, so the read variant is the array alone.
+*
+* @example An array the server may grow or shrink
+* ```ts
+* import { Schema } from "effect";
+* import { FieldValue, FirestoreSchema } from "@visiolab/effect-firebase/firestore";
+*
+* const Tags = FirestoreSchema.ArrayOr(Schema.String);
+*
+* Schema.is(Tags)(["news"]); // true
+* Schema.is(Tags)(FieldValue.arrayUnion("news")); // true
+* ```
+*
+* @see {@link FirestoreModel.Array} for the model field built on it
+* @see {@link ArrayUnion} for the growing sentinel's schema
+* @see {@link ArrayRemove} for the shrinking sentinel's schema
+*
+* @stability unstable
+* @category schemas
+* @since 0.2.0
+*/
+const ArrayOr = ArrayOr$1;
+export { ArrayOr, ArrayRemove, ArrayUnion, DeleteField, DeleteFieldOr, DocumentPath, DocumentReference, FirestoreSchema_exports, GeoPoint, Increment, IncrementOr, ServerTimestamp, ServerTimestampOr, Timestamp };

package/dist/firestore/FirestoreValue.d.mts

@@ -0,0 +1,145 @@
+import { DocumentPath } from "./DocumentPath.mjs";
+import { ArrayRemove, ArrayUnion, DeleteField, Increment, ServerTimestamp } from "./FieldValue.mjs";
+import { GeoPoint } from "./GeoPoint.mjs";
+import { Timestamp } from "./Timestamp.mjs";
+import { FirestoreError } from "./internal/firestoreError.mjs";
+import { FieldPath as FieldPath$1, Kinds as Kinds$1, Reader as Reader$1, Writer as Writer$1 } from "./internal/firestoreValueWalk.mjs";
+import "./Firestore.mjs";
+import { Result, Schema, SchemaAST } from "effect";
+declare namespace FirestoreValue_d_exports {
+  export { FieldPath, FirestoreValue, Kinds, Reader, Writer, formatFieldPath, fromSdk, isFirestoreValue, readDocument, toCodecFirestore, toSdk };
+}
+declare module "effect/Schema" {
+  namespace Annotations {
+    interface Declaration<T, TypeParameters extends ReadonlyArray<Constraint> = readonly []> {
+      /**
+       * Returns the link used to derive the declaration's Firestore
+       * representation, or `undefined` when it already holds a Firestore Value.
+       *
+       * {@link toCodecFirestore} prefers it to `toCodecJson` and `toCodec`.
+       */
+      readonly toCodecFirestore?: ((typeParameters: TypeParameters.Encoded<TypeParameters>) => SchemaAST.Link | undefined) | undefined;
+    }
+  }
+}
+/**
+ * A value as Firestore stores it, independent of either SDK.
+ *
+ * **Details**
+ *
+ * One of: `null`, a boolean, a number, a string, a {@link Timestamp.Timestamp},
+ * a {@link GeoPoint.GeoPoint}, a {@link DocumentPath.DocumentPath}, bytes as a
+ * `Uint8Array`, a {@link FieldValue} sentinel, or an array or plain-object map
+ * of Firestore Values.
+ *
+ * A typed {@link Collection.DocumentReference} is not one: Firestore stores
+ * only its path, as a {@link DocumentPath.DocumentPath}.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.2.0
+ */
+export type FirestoreValue = null | boolean | number | string | Timestamp | GeoPoint | DocumentPath | Uint8Array | ServerTimestamp | Increment | DeleteField | ArrayUnion<FirestoreValue> | ArrayRemove<FirestoreValue> | ReadonlyArray<FirestoreValue> | {
+  readonly [key: string]: FirestoreValue;
+};
+/**
+ * Checks whether `u` is a {@link FirestoreValue}, all the way down.
+ *
+ * **Details**
+ *
+ * Maps must be plain objects. An instance of any other class is not a
+ * Firestore Value, since Firestore would store it as a map and read it back as
+ * a plain object.
+ *
+ * @stability unstable
+ * @category guards
+ * @since 0.2.0
+ */
+export declare const isFirestoreValue: (u: unknown) => u is FirestoreValue;
+/** @internal */
+export type FieldPath = FieldPath$1;
+/** @internal */
+export type Kinds = Kinds$1;
+/** @internal */
+export type Writer = Writer$1;
+/** @internal */
+export type Reader = Reader$1;
+/** @internal */
+export declare const formatFieldPath: (path: FieldPath) => string;
+/** @internal */
+export declare const toSdk: (value: FirestoreValue, writer: Writer) => unknown;
+/** @internal */
+export declare const fromSdk: (value: unknown, reader: Reader) => Result.Result<FirestoreValue, FirestoreError>;
+/** @internal */
+export declare const readDocument: (path: string, data: unknown, reader: Reader) => Result.Result<FirestoreValue | undefined, FirestoreError>;
+/**
+ * Type-level representation of the codec {@link toCodecFirestore} returns: the
+ * schema's `Type`, encoded as a {@link FirestoreValue}.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.2.0
+ */
+export interface toCodecFirestore<S extends Schema.Constraint> extends Schema.BottomLazy<S["ast"], toCodecFirestore<S>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+  readonly Type: S["Type"];
+  readonly Encoded: FirestoreValue;
+  readonly DecodingServices: S["DecodingServices"];
+  readonly EncodingServices: S["EncodingServices"];
+  readonly "~type.make.in": S["~type.make.in"];
+  readonly "~type.make": S["~type.make"];
+  readonly Iso: S["Iso"];
+  readonly schema: S;
+}
+/**
+ * Derives a codec from a schema to Firestore Values.
+ *
+ * **When to use**
+ *
+ * Use to encode or decode a value the way {@link Firestore} stores it outside
+ * a read or write, such as in a test or a custom backend. Reads and writes
+ * through {@link Firestore} already use it.
+ *
+ * **Details**
+ *
+ * It works like `Schema.toCodecJson`: the schema's own transformations run
+ * first, then structs, tuples, arrays, unions and `Schema.suspend` are walked.
+ * A declaration is resolved in this order:
+ *
+ * 1. `Schema.Date` and `Schema.DateTimeUtc` become a portable `Timestamp`, and
+ *    `Schema.Uint8Array` is stored as bytes. Reading a `Date` or `DateTime.Utc`
+ *    back keeps milliseconds only.
+ * 2. A `toCodecFirestore` annotation.
+ * 3. A `toCodecJson` annotation, since every JSON value is a Firestore Value.
+ * 4. A `toCodec` annotation.
+ * 5. Otherwise the value must already be a Firestore Value, and encoding
+ *    anything else fails with a schema issue at its path.
+ *
+ * Keywords follow `Schema.toCodecJson`: a `bigint` or `symbol` is written as a
+ * string, and `undefined` as `null`. Unlike there, `Schema.Any` is no escape
+ * hatch: like `Schema.Unknown` it takes Firestore Values only, since the SDK
+ * mappings take nothing else. Derivation never fails and is memoized per
+ * schema.
+ *
+ * @example Encoding a value to Firestore Values
+ * ```ts
+ * import { DateTime, Effect, Schema } from "effect";
+ * import { FirestoreValue } from "@visiolab/effect-firebase/firestore";
+ *
+ * const Event = Schema.Struct({ name: Schema.String, at: Schema.DateTimeUtc });
+ * const codec = FirestoreValue.toCodecFirestore(Event);
+ *
+ * // `at` is encoded as a portable `Timestamp`.
+ * const encoded = Schema.encodeEffect(codec)({
+ *   name: "launch",
+ *   at: DateTime.makeUnsafe("2024-01-01T00:00:00Z"),
+ * });
+ * ```
+ *
+ * @see {@link FirestoreSchema} for schemas of the values Effect has none for
+ *
+ * @stability unstable
+ * @category converting
+ * @since 0.2.0
+ */
+export declare const toCodecFirestore: <S extends Schema.Constraint>(schema: S) => toCodecFirestore<S>;
+export { FirestoreValue_d_exports };

package/dist/firestore/FirestoreValue.mjs

@@ -0,0 +1,87 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { formatFieldPath as formatFieldPath$1, fromSdk as fromSdk$1, readDocument as readDocument$1, toSdk as toSdk$1 } from "./internal/firestoreValueWalk.mjs";
+import { isFirestoreValue as isFirestoreValue$1, toCodecFirestore as toCodecFirestore$1 } from "./internal/firestoreValue.mjs";
+// src/firestore/FirestoreValue.ts
+var FirestoreValue_exports = /* @__PURE__ */ __exportAll({
+	formatFieldPath: () => formatFieldPath,
+	fromSdk: () => fromSdk,
+	isFirestoreValue: () => isFirestoreValue,
+	readDocument: () => readDocument,
+	toCodecFirestore: () => toCodecFirestore,
+	toSdk: () => toSdk
+});
+/**
+* Checks whether `u` is a {@link FirestoreValue}, all the way down.
+*
+* **Details**
+*
+* Maps must be plain objects. An instance of any other class is not a
+* Firestore Value, since Firestore would store it as a map and read it back as
+* a plain object.
+*
+* @stability unstable
+* @category guards
+* @since 0.2.0
+*/
+const isFirestoreValue = isFirestoreValue$1;
+/** @internal */
+const formatFieldPath = formatFieldPath$1;
+/** @internal */
+const toSdk = toSdk$1;
+/** @internal */
+const fromSdk = fromSdk$1;
+/** @internal */
+const readDocument = readDocument$1;
+/**
+* Derives a codec from a schema to Firestore Values.
+*
+* **When to use**
+*
+* Use to encode or decode a value the way {@link Firestore} stores it outside
+* a read or write, such as in a test or a custom backend. Reads and writes
+* through {@link Firestore} already use it.
+*
+* **Details**
+*
+* It works like `Schema.toCodecJson`: the schema's own transformations run
+* first, then structs, tuples, arrays, unions and `Schema.suspend` are walked.
+* A declaration is resolved in this order:
+*
+* 1. `Schema.Date` and `Schema.DateTimeUtc` become a portable `Timestamp`, and
+*    `Schema.Uint8Array` is stored as bytes. Reading a `Date` or `DateTime.Utc`
+*    back keeps milliseconds only.
+* 2. A `toCodecFirestore` annotation.
+* 3. A `toCodecJson` annotation, since every JSON value is a Firestore Value.
+* 4. A `toCodec` annotation.
+* 5. Otherwise the value must already be a Firestore Value, and encoding
+*    anything else fails with a schema issue at its path.
+*
+* Keywords follow `Schema.toCodecJson`: a `bigint` or `symbol` is written as a
+* string, and `undefined` as `null`. Unlike there, `Schema.Any` is no escape
+* hatch: like `Schema.Unknown` it takes Firestore Values only, since the SDK
+* mappings take nothing else. Derivation never fails and is memoized per
+* schema.
+*
+* @example Encoding a value to Firestore Values
+* ```ts
+* import { DateTime, Effect, Schema } from "effect";
+* import { FirestoreValue } from "@visiolab/effect-firebase/firestore";
+*
+* const Event = Schema.Struct({ name: Schema.String, at: Schema.DateTimeUtc });
+* const codec = FirestoreValue.toCodecFirestore(Event);
+*
+* // `at` is encoded as a portable `Timestamp`.
+* const encoded = Schema.encodeEffect(codec)({
+*   name: "launch",
+*   at: DateTime.makeUnsafe("2024-01-01T00:00:00Z"),
+* });
+* ```
+*
+* @see {@link FirestoreSchema} for schemas of the values Effect has none for
+*
+* @stability unstable
+* @category converting
+* @since 0.2.0
+*/
+const toCodecFirestore = toCodecFirestore$1;
+export { FirestoreValue_exports, formatFieldPath, fromSdk, isFirestoreValue, readDocument, toCodecFirestore, toSdk };