@visiolab/effect-firebase 0.0.0-stage → 0.3.1

package/dist/firestore/DocumentSnapshot.d.mts

@@ -0,0 +1,239 @@
+import { Any, DocumentReference, DocumentSchema, Id } from "./Collection.mjs";
+import { Effect, Inspectable, Schema } from "effect";
+declare namespace DocumentSnapshot_d_exports {
+  export { Data, DecodingServices, DocumentSnapshot, Existing, Missing, existing, isDocumentSnapshot, isExisting, isMissing, make, missing };
+}
+declare const TypeId = "~@visiolab/effect-firebase/firestore/DocumentSnapshot";
+/**
+ * What a document in `C` decodes into: the `read` variant of its model.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.2.0
+ */
+export type Data<C extends Any> = DocumentSchema<C>["Type"];
+/**
+ * The services decoding a document in `C` requires, which
+ * {@link Existing.data} asks for.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.2.0
+ */
+export type DecodingServices<C extends Any> = DocumentSchema<C>["DecodingServices"];
+/**
+ * A snapshot of a document that was there when it was read.
+ *
+ * **Details**
+ *
+ * Its tag is `"Existing"`. {@link Existing.data} decodes what it held through
+ * the collection's model. Every document of a {@link QuerySnapshot.QuerySnapshot}
+ * is one of these.
+ *
+ * @see {@link Missing} for a document that was not there
+ * @see {@link isExisting} for narrowing a {@link DocumentSnapshot} to this
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.2.0
+ */
+export interface Existing<C extends Any> extends Inspectable.Inspectable {
+  readonly [TypeId]: typeof TypeId;
+  readonly _tag: "Existing";
+  /** The reference the document was read at. */
+  readonly ref: DocumentReference<C>;
+  /** The document's own id, the same as `ref.id`. */
+  readonly id: Id<C>;
+  /**
+   * The document's data as the SDK read it, before the collection's model has
+   * decoded it.
+   *
+   * **Details**
+   *
+   * It is what the document held at the time of the read. Do not change it: a
+   * snapshot is a record of that read, not a handle on the document.
+   *
+   * @see {@link Existing.data} for the decoded data
+   */
+  readonly raw: unknown;
+  /**
+   * Decodes {@link Existing.raw} through the collection's model.
+   *
+   * **Details**
+   *
+   * Nothing is decoded until this runs, and it decodes again on each run.
+   * Fails with a `Schema.SchemaError` when the data does not match the model.
+   */
+  readonly data: Effect.Effect<Data<C>, Schema.SchemaError, DecodingServices<C>>;
+}
+/**
+ * A snapshot of a document that was not there when it was read.
+ *
+ * **Details**
+ *
+ * Its tag is `"Missing"`. It holds no data, so a missing document is never
+ * confused with one that failed to decode.
+ *
+ * @see {@link Existing} for a document that was there
+ * @see {@link isMissing} for narrowing a {@link DocumentSnapshot} to this
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.2.0
+ */
+export interface Missing<C extends Any> extends Inspectable.Inspectable {
+  readonly [TypeId]: typeof TypeId;
+  readonly _tag: "Missing";
+  /** The reference the document was read at. */
+  readonly ref: DocumentReference<C>;
+  /** The document's own id, the same as `ref.id`. */
+  readonly id: Id<C>;
+}
+/**
+ * A document in `C` as a read found it: {@link Existing} or {@link Missing}.
+ *
+ * **Details**
+ *
+ * {@link Firestore.With.getDoc} and {@link Firestore.With.streamDoc} return
+ * one. A missing document is a result, not a failure. Tell the two apart with
+ * {@link isExisting} or {@link isMissing}, or by `_tag`.
+ *
+ * @see {@link QuerySnapshot.QuerySnapshot} for the result of a read of many documents
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.2.0
+ */
+export type DocumentSnapshot<C extends Any> = Existing<C> | Missing<C>;
+/**
+ * Checks whether a value is a {@link DocumentSnapshot}, existing or missing.
+ *
+ * @see {@link isExisting} and {@link isMissing} for telling the two kinds apart
+ * @see {@link QuerySnapshot.isQuerySnapshot} for a snapshot of many documents
+ *
+ * @stability unstable
+ * @category guards
+ * @since 0.2.0
+ */
+export declare const isDocumentSnapshot: (u: unknown) => u is DocumentSnapshot<Any>;
+/**
+ * Narrows a {@link DocumentSnapshot} to an {@link Existing} one.
+ *
+ * **When to use**
+ *
+ * Use after {@link Firestore.With.getDoc} to get at the data of a document
+ * that was there.
+ *
+ * @see {@link isMissing} for the opposite check
+ *
+ * @stability unstable
+ * @category guards
+ * @since 0.2.0
+ */
+export declare const isExisting: <C extends Any>(self: DocumentSnapshot<C>) => self is Existing<C>;
+/**
+ * Narrows a {@link DocumentSnapshot} to a {@link Missing} one.
+ *
+ * **When to use**
+ *
+ * Use after {@link Firestore.With.getDoc} to handle a document that was not
+ * there, such as returning early.
+ *
+ * @see {@link isExisting} for the opposite check
+ *
+ * @stability unstable
+ * @category guards
+ * @since 0.2.0
+ */
+export declare const isMissing: <C extends Any>(self: DocumentSnapshot<C>) => self is Missing<C>;
+/**
+ * Builds a snapshot of the document at `ref` from what an SDK's
+ * `snapshot.data()` returned: {@link Missing} for `undefined`, and
+ * {@link Existing} otherwise.
+ *
+ * **When to use**
+ *
+ * Use when implementing a backend or a test double, to turn an SDK snapshot
+ * into a portable one. Application code gets snapshots from
+ * {@link Firestore.With.getDoc} instead.
+ *
+ * **Details**
+ *
+ * Both SDKs return `undefined` from `data()` for a document that is not there.
+ * An SDK that knows more about the read, such as the client's `metadata`,
+ * passes it as `extra`: each of its fields is put on the snapshot and shown
+ * when it prints. Its fields must not have the same names as the snapshot's
+ * own.
+ *
+ * @example Building a snapshot with extra fields
+ * ```ts
+ * import {
+ *   Collection,
+ *   DocumentSnapshot,
+ *   FirestoreModel,
+ * } from "@visiolab/effect-firebase/firestore";
+ * import { Schema } from "effect";
+ *
+ * class User extends FirestoreModel.Class<User>("User")({ name: Schema.String }) {}
+ *
+ * const Users = Collection.make("users", User);
+ * const ref = Users.doc(Users.id.make("alice"));
+ *
+ * const snapshot = DocumentSnapshot.make(ref, { name: "Alice" }, {
+ *   metadata: { fromCache: false, hasPendingWrites: false },
+ * });
+ *
+ * snapshot.metadata.fromCache; // false
+ * ```
+ *
+ * @see {@link existing} for a document known to be there
+ * @see {@link missing} for a document known not to be there
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.2.0
+ */
+export declare const make: {
+  <C extends Any>(ref: DocumentReference<C>, data: unknown): DocumentSnapshot<C>;
+  <C extends Any, E extends object>(ref: DocumentReference<C>, data: unknown, extra: E): DocumentSnapshot<C> & E;
+};
+/**
+ * Builds an {@link Existing} snapshot of the document at `ref`, with the
+ * fields of `extra` when given, as {@link make} adds them.
+ *
+ * **When to use**
+ *
+ * Use in a backend for a document known to be there, such as each document a
+ * query returned.
+ *
+ * @see {@link make} for a document that may or may not be there
+ * @see {@link missing} for a document known not to be there
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.2.0
+ */
+export declare const existing: {
+  <C extends Any>(ref: DocumentReference<C>, data: unknown): Existing<C>;
+  <C extends Any, E extends object>(ref: DocumentReference<C>, data: unknown, extra: E): Existing<C> & E;
+};
+/**
+ * Builds a {@link Missing} snapshot of the document at `ref`, with the fields
+ * of `extra` when given, as {@link make} adds them.
+ *
+ * **When to use**
+ *
+ * Use in a backend or a test double for a document known not to be there.
+ *
+ * @see {@link make} for a document that may or may not be there
+ * @see {@link existing} for a document known to be there
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.2.0
+ */
+export declare const missing: {
+  <C extends Any>(ref: DocumentReference<C>): Missing<C>;
+  <C extends Any, E extends object>(ref: DocumentReference<C>, extra: E): Missing<C> & E;
+};
+export { DocumentSnapshot_d_exports };

package/dist/firestore/DocumentSnapshot.mjs

@@ -0,0 +1,134 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { existing as existing$1, isDocumentSnapshot as isDocumentSnapshot$1, isExisting as isExisting$1, isMissing as isMissing$1, make as make$1, missing as missing$1 } from "./internal/documentSnapshot.mjs";
+// src/firestore/DocumentSnapshot.ts
+var DocumentSnapshot_exports = /* @__PURE__ */ __exportAll({
+	existing: () => existing,
+	isDocumentSnapshot: () => isDocumentSnapshot,
+	isExisting: () => isExisting,
+	isMissing: () => isMissing,
+	make: () => make,
+	missing: () => missing
+});
+/**
+* Checks whether a value is a {@link DocumentSnapshot}, existing or missing.
+*
+* @see {@link isExisting} and {@link isMissing} for telling the two kinds apart
+* @see {@link QuerySnapshot.isQuerySnapshot} for a snapshot of many documents
+*
+* @stability unstable
+* @category guards
+* @since 0.2.0
+*/
+const isDocumentSnapshot = isDocumentSnapshot$1;
+/**
+* Narrows a {@link DocumentSnapshot} to an {@link Existing} one.
+*
+* **When to use**
+*
+* Use after {@link Firestore.With.getDoc} to get at the data of a document
+* that was there.
+*
+* @see {@link isMissing} for the opposite check
+*
+* @stability unstable
+* @category guards
+* @since 0.2.0
+*/
+const isExisting = isExisting$1;
+/**
+* Narrows a {@link DocumentSnapshot} to a {@link Missing} one.
+*
+* **When to use**
+*
+* Use after {@link Firestore.With.getDoc} to handle a document that was not
+* there, such as returning early.
+*
+* @see {@link isExisting} for the opposite check
+*
+* @stability unstable
+* @category guards
+* @since 0.2.0
+*/
+const isMissing = isMissing$1;
+/**
+* Builds a snapshot of the document at `ref` from what an SDK's
+* `snapshot.data()` returned: {@link Missing} for `undefined`, and
+* {@link Existing} otherwise.
+*
+* **When to use**
+*
+* Use when implementing a backend or a test double, to turn an SDK snapshot
+* into a portable one. Application code gets snapshots from
+* {@link Firestore.With.getDoc} instead.
+*
+* **Details**
+*
+* Both SDKs return `undefined` from `data()` for a document that is not there.
+* An SDK that knows more about the read, such as the client's `metadata`,
+* passes it as `extra`: each of its fields is put on the snapshot and shown
+* when it prints. Its fields must not have the same names as the snapshot's
+* own.
+*
+* @example Building a snapshot with extra fields
+* ```ts
+* import {
+*   Collection,
+*   DocumentSnapshot,
+*   FirestoreModel,
+* } from "@visiolab/effect-firebase/firestore";
+* import { Schema } from "effect";
+*
+* class User extends FirestoreModel.Class<User>("User")({ name: Schema.String }) {}
+*
+* const Users = Collection.make("users", User);
+* const ref = Users.doc(Users.id.make("alice"));
+*
+* const snapshot = DocumentSnapshot.make(ref, { name: "Alice" }, {
+*   metadata: { fromCache: false, hasPendingWrites: false },
+* });
+*
+* snapshot.metadata.fromCache; // false
+* ```
+*
+* @see {@link existing} for a document known to be there
+* @see {@link missing} for a document known not to be there
+*
+* @stability unstable
+* @category constructors
+* @since 0.2.0
+*/
+const make = make$1;
+/**
+* Builds an {@link Existing} snapshot of the document at `ref`, with the
+* fields of `extra` when given, as {@link make} adds them.
+*
+* **When to use**
+*
+* Use in a backend for a document known to be there, such as each document a
+* query returned.
+*
+* @see {@link make} for a document that may or may not be there
+* @see {@link missing} for a document known not to be there
+*
+* @stability unstable
+* @category constructors
+* @since 0.2.0
+*/
+const existing = existing$1;
+/**
+* Builds a {@link Missing} snapshot of the document at `ref`, with the fields
+* of `extra` when given, as {@link make} adds them.
+*
+* **When to use**
+*
+* Use in a backend or a test double for a document known not to be there.
+*
+* @see {@link make} for a document that may or may not be there
+* @see {@link existing} for a document known to be there
+*
+* @stability unstable
+* @category constructors
+* @since 0.2.0
+*/
+const missing = missing$1;
+export { DocumentSnapshot_exports, existing, isDocumentSnapshot, isExisting, isMissing, make, missing };

package/dist/firestore/FieldValue.d.mts

@@ -0,0 +1,332 @@
+import { Equal, Inspectable } from "effect";
+declare namespace FieldValue_d_exports {
+  export { ArrayRemove, ArrayUnion, DeleteField, Increment, ServerTimestamp, arrayRemove, arrayUnion, decrement, deleteField, increment, isArrayRemove, isArrayUnion, isDeleteField, isIncrement, isServerTimestamp, serverTimestamp };
+}
+declare const ServerTimestampTypeId = "~@visiolab/effect-firebase/firestore/FieldValue/ServerTimestamp";
+/**
+ * The sentinel for the time the server applies the write. Its only value is
+ * {@link serverTimestamp}.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.2.0
+ */
+export interface ServerTimestamp extends Inspectable.Inspectable {
+  readonly [ServerTimestampTypeId]: typeof ServerTimestampTypeId;
+}
+/**
+ * Asks the server to write the time it applies the write.
+ *
+ * **When to use**
+ *
+ * Use for fields such as `createdAt` and `updatedAt` that every client should
+ * agree on. The local clock differs between clients, the server's does not.
+ *
+ * **Details**
+ *
+ * It carries nothing, so there is only this one value. The field reads back as
+ * the timestamp the server wrote.
+ *
+ * @example Stamping a document with the server's time
+ * ```ts
+ * import { Schema } from "effect";
+ * import { FieldValue, FirestoreModel } from "@visiolab/effect-firebase/firestore";
+ *
+ * class Post extends FirestoreModel.Class<Post>("Post")({
+ *   updatedAt: FirestoreModel.Timestamp(Schema.DateTimeUtc),
+ * }) {}
+ *
+ * Post.update.make({ updatedAt: FieldValue.serverTimestamp });
+ * ```
+ *
+ * @see {@link Timestamp.now} for the local time instead
+ * @see {@link FirestoreModel.Timestamp} for a model field that accepts it
+ * @see {@link FirestoreSchema.ServerTimestampOr} for a schema that accepts it
+ * @see {@link FirestoreSchema.ServerTimestamp} for a schema that always writes it
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.2.0
+ */
+export declare const serverTimestamp: ServerTimestamp;
+/**
+ * Checks whether `u` is the {@link ServerTimestamp} sentinel.
+ *
+ * @stability unstable
+ * @category guards
+ * @since 0.2.0
+ */
+export declare const isServerTimestamp: (u: unknown) => u is ServerTimestamp;
+declare const IncrementTypeId = "~@visiolab/effect-firebase/firestore/FieldValue/Increment";
+/**
+ * The sentinel for a number the server moves by `by`. Built by
+ * {@link increment} and {@link decrement}.
+ *
+ * **Details**
+ *
+ * The server adds `by` to what the field holds. A field that holds no number,
+ * or is missing, counts as zero. Two sentinels are equal when their `by` is.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.2.0
+ */
+export interface Increment extends Equal.Equal, Inspectable.Inspectable {
+  readonly [IncrementTypeId]: typeof IncrementTypeId;
+  /** How far the field moves; negative to lower it. */
+  readonly by: number;
+}
+/**
+ * Checks whether `u` is an {@link Increment} sentinel.
+ *
+ * @stability unstable
+ * @category guards
+ * @since 0.2.0
+ */
+export declare const isIncrement: (u: unknown) => u is Increment;
+/**
+ * Asks the server to raise a number field by `by`.
+ *
+ * **When to use**
+ *
+ * Use for counters and totals that several clients may change at once. Two
+ * clients that each read a number and write back the sum lose one of the
+ * changes; two increments do not.
+ *
+ * **Details**
+ *
+ * Throws unless `by` is a finite number. Integers and doubles both work; an
+ * integer added to a double gives a double. A field that holds no number, or
+ * is missing, counts as zero.
+ *
+ * @example Counting a visit
+ * ```ts
+ * import { Schema } from "effect";
+ * import { FieldValue, FirestoreModel } from "@visiolab/effect-firebase/firestore";
+ *
+ * class Page extends FirestoreModel.Class<Page>("Page")({
+ *   visits: FirestoreModel.Number(Schema.Int),
+ * }) {}
+ *
+ * Page.update.make({ visits: FieldValue.increment(1) });
+ * ```
+ *
+ * @see {@link decrement} for lowering a field
+ * @see {@link FirestoreModel.Number} for a model field that accepts it
+ * @see {@link FirestoreSchema.IncrementOr} for a schema that accepts it
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.2.0
+ */
+export declare const increment: (by: number) => Increment;
+/**
+ * Asks the server to lower a number field by `by`.
+ *
+ * **When to use**
+ *
+ * Use where the code counts down, so it reads that way rather than as an
+ * increment by a negative number.
+ *
+ * **Details**
+ *
+ * It is {@link increment} of `-by`: `decrement(2).by` is `-2`.
+ *
+ * @see {@link increment} for raising a field
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.2.0
+ */
+export declare const decrement: (by: number) => Increment;
+declare const DeleteFieldTypeId = "~@visiolab/effect-firebase/firestore/FieldValue/DeleteField";
+/**
+ * The sentinel for a field an update removes. Its only value is
+ * {@link deleteField}.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.2.0
+ */
+export interface DeleteField extends Inspectable.Inspectable {
+  readonly [DeleteFieldTypeId]: typeof DeleteFieldTypeId;
+}
+/**
+ * Asks the server to remove a field.
+ *
+ * **When to use**
+ *
+ * Use in an update to remove an optional field. Leaving a field out of an
+ * update keeps it as it is, so removing one has to be asked for.
+ *
+ * **Details**
+ *
+ * After the write, the document has no key at all for the field, not one
+ * holding `null`. Only an update accepts it: a document written whole with
+ * `setDoc` drops a field by leaving it out, and Firestore refuses the sentinel
+ * there.
+ *
+ * It carries nothing, so there is only this one value. It is not called
+ * `delete` because that is a reserved word in JavaScript, which is also why the
+ * client SDK calls its own `deleteField`.
+ *
+ * @example Removing an optional field
+ * ```ts
+ * import { Schema } from "effect";
+ * import { FieldValue, FirestoreModel } from "@visiolab/effect-firebase/firestore";
+ *
+ * class User extends FirestoreModel.Class<User>("User")({
+ *   nickname: FirestoreModel.Optional(Schema.String),
+ * }) {}
+ *
+ * User.update.make({ nickname: FieldValue.deleteField });
+ * ```
+ *
+ * @see {@link FirestoreModel.Optional} for a model field that accepts it
+ * @see {@link FirestoreSchema.DeleteFieldOr} for a schema that accepts it
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.2.0
+ */
+export declare const deleteField: DeleteField;
+/**
+ * Checks whether `u` is the {@link DeleteField} sentinel.
+ *
+ * @stability unstable
+ * @category guards
+ * @since 0.2.0
+ */
+export declare const isDeleteField: (u: unknown) => u is DeleteField;
+declare const ArrayUnionTypeId = "~@visiolab/effect-firebase/firestore/FieldValue/ArrayUnion";
+/**
+ * The sentinel for an array the server adds `elements` to. Built by
+ * {@link arrayUnion}.
+ *
+ * **Details**
+ *
+ * The server appends each element the array does not already hold. It compares
+ * by value, all the way down: a map matches one with the same keys holding the
+ * same values, whatever their order. A field that holds no array, or is
+ * missing, ends up holding just `elements`.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.2.0
+ */
+export interface ArrayUnion<A> extends Inspectable.Inspectable {
+  readonly [ArrayUnionTypeId]: typeof ArrayUnionTypeId;
+  /** The elements to add, in the order they are appended. */
+  readonly elements: ReadonlyArray<A>;
+}
+/**
+ * Checks whether `u` is an {@link ArrayUnion} sentinel.
+ *
+ * @stability unstable
+ * @category guards
+ * @since 0.2.0
+ */
+export declare const isArrayUnion: (u: unknown) => u is ArrayUnion<unknown>;
+/**
+ * Asks the server to add `elements` to an array, skipping any it holds already.
+ *
+ * **When to use**
+ *
+ * Use to add to an array that several clients may change at once. A client
+ * that reads the array, adds an element and writes it back loses whatever
+ * another client added in between; `arrayUnion` does not.
+ *
+ * **Details**
+ *
+ * Elements are compared by value, as {@link ArrayUnion} describes. With no
+ * elements it changes nothing, except that a field that held no array ends up
+ * holding an empty one.
+ *
+ * @example Adding a tag
+ * ```ts
+ * import { Schema } from "effect";
+ * import { FieldValue, FirestoreModel } from "@visiolab/effect-firebase/firestore";
+ *
+ * class Article extends FirestoreModel.Class<Article>("Article")({
+ *   tags: FirestoreModel.Array(Schema.String),
+ * }) {}
+ *
+ * Article.update.make({ tags: FieldValue.arrayUnion("news") });
+ * ```
+ *
+ * @see {@link arrayRemove} for removing elements
+ * @see {@link FirestoreModel.Array} for a model field that accepts it
+ * @see {@link FirestoreSchema.ArrayOr} for a schema that accepts it
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.2.0
+ */
+export declare const arrayUnion: <A>(...elements: ReadonlyArray<A>) => ArrayUnion<A>;
+declare const ArrayRemoveTypeId = "~@visiolab/effect-firebase/firestore/FieldValue/ArrayRemove";
+/**
+ * The sentinel for an array the server removes `elements` from. Built by
+ * {@link arrayRemove}.
+ *
+ * **Details**
+ *
+ * The server drops every element equal to one of `elements`. The match is by
+ * value, as for {@link ArrayUnion}, and exact: an element with an extra key, or
+ * a different number, is a different element and stays. To remove a map from
+ * an array you must pass every key it holds, with the same values. Where
+ * elements have an id of their own, a map keyed by that id is easier to remove
+ * from. A field that holds no array, or is missing, ends up holding an empty
+ * one.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.2.0
+ */
+export interface ArrayRemove<A> extends Inspectable.Inspectable {
+  readonly [ArrayRemoveTypeId]: typeof ArrayRemoveTypeId;
+  /** The elements to remove, wherever they are in the array. */
+  readonly elements: ReadonlyArray<A>;
+}
+/**
+ * Checks whether `u` is an {@link ArrayRemove} sentinel.
+ *
+ * @stability unstable
+ * @category guards
+ * @since 0.2.0
+ */
+export declare const isArrayRemove: (u: unknown) => u is ArrayRemove<unknown>;
+/**
+ * Asks the server to remove every element equal to one of `elements` from an
+ * array.
+ *
+ * **When to use**
+ *
+ * Use to remove from an array that several clients may change at once, keeping
+ * whatever they add in the meantime.
+ *
+ * **Details**
+ *
+ * The match is exact, as {@link ArrayRemove} describes.
+ *
+ * @example Removing a tag
+ * ```ts
+ * import { Schema } from "effect";
+ * import { FieldValue, FirestoreModel } from "@visiolab/effect-firebase/firestore";
+ *
+ * class Article extends FirestoreModel.Class<Article>("Article")({
+ *   tags: FirestoreModel.Array(Schema.String),
+ * }) {}
+ *
+ * Article.update.make({ tags: FieldValue.arrayRemove("draft") });
+ * ```
+ *
+ * @see {@link arrayUnion} for adding elements
+ * @see {@link FirestoreModel.Array} for a model field that accepts it
+ * @see {@link FirestoreSchema.ArrayOr} for a schema that accepts it
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.2.0
+ */
+export declare const arrayRemove: <A>(...elements: ReadonlyArray<A>) => ArrayRemove<A>;
+export { FieldValue_d_exports };