@visiolab/effect-firebase 0.0.0-stage → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VisioLab GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,82 @@
-# Temporary Holding Version
+# @visiolab/effect-firebase
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Typed Firestore collections and Firebase services for [Effect](https://effect.website), independent of any Firebase SDK.
+
+This package defines the services and the document models. Two packages implement them:
+
+| Package                                                                                                     | Runs on               | SDK              |
+| ----------------------------------------------------------------------------------------------------------- | --------------------- | ---------------- |
+| [`@visiolab/effect-firebase-admin`](https://github.com/VisioLab/effect-firebase/tree/main/packages/admin)   | servers and functions | `firebase-admin` |
+| [`@visiolab/effect-firebase-client`](https://github.com/VisioLab/effect-firebase/tree/main/packages/client) | browsers and apps     | `firebase`       |
+
+Code written against this package, such as models, collections and the portable `Firestore` service, runs unchanged on either.
+
+## Install
+
+```sh
+pnpm add effect @visiolab/effect-firebase @visiolab/effect-firebase-admin firebase-admin
+# or, in a browser or app
+pnpm add effect @visiolab/effect-firebase @visiolab/effect-firebase-client firebase
+```
+
+## Example
+
+Define a document with `FirestoreModel.Class`, where it lives with `Collection.make`, and read and write it through the `Firestore` service:
+
+```ts
+import { Effect, Layer, Schema } from "effect";
+import {
+  Collection,
+  DocumentSnapshot,
+  Firestore,
+  FirestoreModel,
+} from "@visiolab/effect-firebase/firestore";
+import { App } from "@visiolab/effect-firebase-admin/app";
+import { AdminFirestore } from "@visiolab/effect-firebase-admin/firestore";
+
+class User extends FirestoreModel.Class<User>("User")({
+  name: Schema.String,
+  visits: FirestoreModel.Number(Schema.Int),
+}) {}
+
+const Users = Collection.make("users", User);
+
+const program = Effect.gen(function* () {
+  const firestore = yield* Firestore.Firestore;
+  const alice = Users.doc(Users.id.make("alice"));
+
+  yield* firestore.setDoc(alice, { name: "Alice", visits: 0 });
+
+  const snapshot = yield* firestore.getDoc(alice);
+  if (DocumentSnapshot.isExisting(snapshot)) {
+    const user = yield* snapshot.data;
+    yield* Effect.log(`${user.name} has visited ${user.visits} times`);
+  }
+});
+
+const FirestoreLive = AdminFirestore.layer().pipe(Layer.provide(App.layer()));
+
+Effect.runPromise(program.pipe(Effect.provide(FirestoreLive)));
+```
+
+`program` only asks for the portable `Firestore`, so providing `ClientFirestore.layer` from `@visiolab/effect-firebase-client` runs it on the client SDK instead.
+
+## Modules
+
+Everything is exported from `@visiolab/effect-firebase/firestore`, and each module from its own path, such as `@visiolab/effect-firebase/firestore/Collection`.
+
+| Module             | What it is for                                                                    |
+| ------------------ | --------------------------------------------------------------------------------- |
+| `Firestore`        | The service: read, listen to, write and update documents, and run transactions.   |
+| `FirestoreModel`   | Document models, with the shapes a document is created, updated and read in.      |
+| `FirestoreSchema`  | Schemas for Firestore's own values, such as timestamps and server-side sentinels. |
+| `Collection`       | Where documents live, and typed references to them.                               |
+| `CollectionGroup`  | Every collection with the same id, read together.                                 |
+| `DocumentSnapshot` | A document as a read found it: there or missing.                                  |
+| `QuerySnapshot`    | The documents a read of a collection or group found.                              |
+| `FieldValue`       | Server-side writes: `serverTimestamp`, `increment`, `arrayUnion` and the others.  |
+| `Patch`            | `Patch.replace`, to write a nested struct whole in an update.                     |
+| `Timestamp`        | Firestore's timestamp, to the nanosecond.                                         |
+| `GeoPoint`         | Firestore's geographic point.                                                     |
+| `DocumentPath`     | An untyped document reference, as Firestore stores it in a field.                 |
+| `FirestoreValue`   | Values as Firestore stores them, and the codec models encode through.             |

package/dist/_virtual/_rolldown/runtime.mjs

@@ -0,0 +1,12 @@
+// \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+export { __exportAll };

package/dist/app/App.d.mts

@@ -0,0 +1,27 @@
+declare namespace App_d_exports {
+  export { defaultAppName };
+}
+/**
+ * What the SDK packages' `App` modules share.
+ *
+ * The app service itself belongs to each SDK package: see the `App` modules
+ * of [`@visiolab/effect-firebase-admin`](/api/admin/app/App/) and
+ * [`@visiolab/effect-firebase-client`](/api/client/app/App/).
+ *
+ * @stability unstable
+ * @since 0.1.0
+ */
+/**
+ * The name Firebase gives an app that was initialized without one.
+ *
+ * **When to use**
+ *
+ * Use to compare against an app's `name`, or to name the default app
+ * explicitly.
+ *
+ * @stability unstable
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const defaultAppName = "[DEFAULT]";
+export { App_d_exports };

package/dist/app/App.mjs

@@ -0,0 +1,27 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+// src/app/App.ts
+var App_exports = /* @__PURE__ */ __exportAll({ defaultAppName: () => defaultAppName });
+/**
+* What the SDK packages' `App` modules share.
+*
+* The app service itself belongs to each SDK package: see the `App` modules
+* of [`@visiolab/effect-firebase-admin`](/api/admin/app/App/) and
+* [`@visiolab/effect-firebase-client`](/api/client/app/App/).
+*
+* @stability unstable
+* @since 0.1.0
+*/
+/**
+* The name Firebase gives an app that was initialized without one.
+*
+* **When to use**
+*
+* Use to compare against an app's `name`, or to name the default app
+* explicitly.
+*
+* @stability unstable
+* @category constants
+* @since 0.1.0
+*/
+const defaultAppName = "[DEFAULT]";
+export { App_exports, defaultAppName };

package/dist/app/index.d.mts

@@ -0,0 +1,2 @@
+import { App_d_exports } from "./App.mjs";
+export { App_d_exports as App };

package/dist/app/index.mjs

@@ -0,0 +1 @@
+export { App_exports as App } from "./App.mjs";

package/dist/firestore/Collection.d.mts

@@ -0,0 +1,423 @@
+import { DocumentSnapshot, Existing, Missing } from "./DocumentSnapshot.mjs";
+import { Any as Any$1 } from "./FirestoreModel.mjs";
+import { Brand, Equal, Inspectable, Option, Schema } from "effect";
+declare namespace Collection_d_exports {
+  export { Ancestors, Any, Collection, CollectionReference, DocumentReference, DocumentSchema, Id, IdSchema, Level, Levels, fromPath, isCollection, isCollectionReference, isDocumentReference, make };
+}
+declare const CollectionTypeId = "~@visiolab/effect-firebase/firestore/Collection";
+declare const CollectionReferenceTypeId = "~@visiolab/effect-firebase/firestore/CollectionReference";
+declare const DocumentReferenceTypeId = "~@visiolab/effect-firebase/firestore/DocumentReference";
+/**
+ * One link of a collection's path: a segment and the model of the documents
+ * stored under it.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.1.0
+ */
+export type Level = readonly [segment: string, schema: Any$1];
+/**
+ * The {@link Level}s from a root collection down to a collection itself.
+ *
+ * **Details**
+ *
+ * A {@link Collection} carries the whole chain rather than only its own
+ * segment, so the id of every ancestor stays typed.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.1.0
+ */
+export type Levels = readonly [Level, ...ReadonlyArray<Level>];
+type Join<S extends ReadonlyArray<string>> = S extends readonly [infer Head extends string, ...infer Tail extends ReadonlyArray<string>] ? Tail extends readonly [] ? Head : `${Head}/${Join<Tail>}` : never;
+/** The last link of the chain. */
+type Leaf<L extends Levels> = L extends readonly [...ReadonlyArray<Level>, infer T extends Level] ? T : never;
+/** The segments of a chain, as a tuple. */
+type SegmentsOf<L extends Levels> = { readonly [K in keyof L]: L[K][0]; };
+/**
+ * Document ids are branded with the collection's path, so an id only ever fits
+ * the collection it came from. Two collections that share a segment - `posts`
+ * under `users` and `posts` under `orgs` - still get distinct ids, because the
+ * brand is the whole path rather than the last segment.
+ */
+type IdOf<L extends Levels> = string & Brand.Brand<Join<SegmentsOf<L>>>;
+/**
+ * One id per ancestor, ordered from the root down. A root collection needs
+ * none, which is why the recursion bottoms out at the empty tuple.
+ *
+ * The parent chain is matched inline rather than looked up through an alias, so
+ * that the recursion stays deferred until `L` is a concrete chain. Going
+ * through an alias makes it eager, and the compiler gives up on the depth.
+ */
+type AncestorsOf<L extends Levels> = L extends readonly [...infer I, Level] ? I extends Levels ? [...AncestorsOf<I>, IdOf<I>] : [] : [];
+/**
+ * What {@link Collection.contains} narrows each member of `V` to: the members
+ * already in `C` are kept, the ones in another collection are dropped, and one
+ * whose collection is left open is narrowed to `C`.
+ *
+ * Every branch is `V` or an intersection with it, which is what lets the
+ * compiler see the result is assignable to `V`, as a type predicate must be.
+ */
+type Contained<V, C extends Any> = V extends DocumentReference<Any> ? NarrowTo<V, DocumentReference<C>> : V extends Existing<Any> ? NarrowTo<V, Existing<C>> : V extends Missing<Any> ? NarrowTo<V, Missing<C>> : never;
+/**
+ * `V` when it is `T`, and `never` when it is not. A `V` whose collection is
+ * `any` passes the check without saying anything about it, so it is narrowed
+ * by intersecting it with `T` instead.
+ */
+type NarrowTo<V, T> = V extends T ? (0 extends 1 & LevelsOf<V> ? V & T : V) : never;
+/** The chain of the collection a reference or snapshot is in. */
+type LevelsOf<V> = V extends DocumentReference<Collection<infer L>> ? L : V extends {
+  readonly ref: DocumentReference<Collection<infer L>>;
+} ? L : never;
+/**
+ * The schema of a document id in one collection. It decodes a string and
+ * brands it with the collection's full path, so the id only fits that
+ * collection.
+ *
+ * **When to use**
+ *
+ * Use `collection.id.make(raw)` to turn a string you trust into an id, and
+ * `Schema.decodeUnknownEffect(collection.id)` to check one from outside.
+ *
+ * **Details**
+ *
+ * The brand is the whole path, so `posts` under `users` and `posts` under
+ * `orgs` have different id types. Its constructor takes a `string`, which
+ * makes passing anything else a type error rather than a runtime throw.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.1.0
+ */
+export interface IdSchema<T extends string> extends Schema.Codec<T, string> {
+  readonly "~type.make.in": string;
+}
+/**
+ * The definition of a collection: where it sits, how its documents are
+ * addressed, and the model they hold.
+ *
+ * **Details**
+ *
+ * A definition does not point at any data. It describes a collection, and
+ * {@link Collection.collection} and {@link Collection.doc} turn it into a
+ * reference once you have the ids that address it. Build one with
+ * {@link make}, and nest one with {@link Collection.subcollection}.
+ *
+ * @see {@link CollectionReference} for a reference to one collection, with its ancestor ids filled in
+ * @see {@link CollectionGroup.CollectionGroup} for every collection with one collection id, read together
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.1.0
+ */
+export interface Collection<L extends Levels> extends Inspectable.Inspectable {
+  readonly [CollectionTypeId]: typeof CollectionTypeId;
+  /** The chain this collection was built from. Only read at the type level. */
+  readonly "~levels": L;
+  /** The path segments, from the root collection down, such as `["users", "posts"]`. */
+  readonly path: SegmentsOf<L>;
+  /** The last segment: the collection id Firestore knows the collection by. */
+  readonly segment: Leaf<L>[0];
+  /**
+   * The schema of the ids of documents in this collection.
+   *
+   * @see {@link IdSchema} for how to make and decode one
+   */
+  readonly id: IdSchema<IdOf<L>>;
+  /**
+   * The model of the documents in this collection. Reads decode through it,
+   * and writes encode through its {@link FirestoreModel.Class.create} and
+   * {@link FirestoreModel.Class.update} variants.
+   */
+  readonly schema: Leaf<L>[1];
+  /**
+   * Checks whether a Document Reference or Document Snapshot belongs to this
+   * collection, and narrows it to this collection's types when it does.
+   *
+   * **When to use**
+   *
+   * Use to pick out the documents of one collection from a mixed result, such
+   * as a read of a {@link CollectionGroup.CollectionGroup} with several
+   * members: `snapshot.docs.filter(UserPosts.contains)`.
+   *
+   * **Details**
+   *
+   * Two definitions are the same collection only when they are the same
+   * object, so a definition built separately at the same path does not
+   * contain this one's documents. It does not use `this`, so it can be passed
+   * on unbound.
+   *
+   * @see {@link isDocumentReference} for checking that a value is a reference to any collection
+   */
+  readonly contains: <V extends DocumentReference<Any> | DocumentSnapshot<Any>>(value: V) => value is Contained<V, Collection<L>>;
+  /**
+   * Defines a subcollection under the documents of this collection.
+   *
+   * **When to use**
+   *
+   * Use for a nested collection, such as `posts` under each user. Use
+   * {@link make} for a root collection.
+   *
+   * **Details**
+   *
+   * Throws when `segment` is not a collection id Firestore accepts: empty,
+   * containing `/`, `.` or `..`, matching `__.*__`, or longer than 1500
+   * bytes. An invalid definition is a programming error, not a failure to
+   * recover from.
+   */
+  subcollection<const Segment extends string, S extends Any$1>(segment: Segment, schema: S): Collection<readonly [...L, readonly [Segment, S]]>;
+  /**
+   * References this collection, given one id per ancestor, from the root down.
+   * A root collection takes none.
+   *
+   * **When to use**
+   *
+   * Use to address the collection itself, as {@link Firestore.With.getDocs},
+   * {@link Firestore.With.streamDocs} and {@link Firestore.With.addDoc} take
+   * it.
+   *
+   * @see {@link Collection.doc} for referencing one document in it
+   */
+  collection(...ids: AncestorsOf<L>): CollectionReference<Collection<L>>;
+  /**
+   * References a document in this collection, given one id per ancestor
+   * followed by the document's own.
+   *
+   * **When to use**
+   *
+   * Use to address one document, as {@link Firestore.With.getDoc},
+   * {@link Firestore.With.setDoc} and {@link Firestore.With.updateDoc} take it.
+   *
+   * @see {@link Collection.collection} for referencing the collection itself
+   * @see {@link fromPath} for a reference from a path string
+   */
+  doc(...ids: [...AncestorsOf<L>, IdOf<L>]): DocumentReference<Collection<L>>;
+}
+/**
+ * Any collection, whatever it is nested under and whatever it holds. Use it as
+ * a type bound.
+ *
+ * **Details**
+ *
+ * It is `Collection<any>` rather than `Collection<Levels>` because `L` sits in
+ * an argument position in {@link Collection.doc}, which makes it invariant.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.1.0
+ */
+export type Any = Collection<any>;
+/**
+ * The id of a document in `C`, branded with `C`'s path.
+ *
+ * @see {@link IdSchema} for how to make one
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.1.0
+ */
+export type Id<C extends Any> = IdOf<C["~levels"]>;
+/**
+ * The ids that address `C`: one per ancestor, from the root down. Empty for a
+ * root collection.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.1.0
+ */
+export type Ancestors<C extends Any> = AncestorsOf<C["~levels"]>;
+/**
+ * The model of the documents in `C`, as {@link make} or
+ * {@link Collection.subcollection} was given it.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.1.0
+ */
+export type DocumentSchema<C extends Any> = Leaf<C["~levels"]>[1];
+/**
+ * A reference to one collection, with the ids of its ancestors filled in.
+ *
+ * **Details**
+ *
+ * Build one with {@link Collection.collection}. Two references are
+ * `Equal` when they have the same path and come from the same definition.
+ *
+ * @see {@link Collection} for the definition it is built from
+ * @see {@link DocumentReference} for a reference to one document
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.1.0
+ */
+export interface CollectionReference<C extends Any> extends Inspectable.Inspectable, Equal.Equal {
+  readonly [CollectionReferenceTypeId]: typeof CollectionReferenceTypeId;
+  /** The definition this reference was built from. */
+  readonly collection: C;
+  /** The ids that address it, from the root down. */
+  readonly ancestors: Readonly<Ancestors<C>>;
+  /** The collection id Firestore knows it by: the last segment of its path. */
+  readonly id: Leaf<C["~levels"]>[0];
+  /** The full path, such as `users/alice/posts`. */
+  readonly path: string;
+  /**
+   * References a document in this collection, by its own id.
+   *
+   * @see {@link Collection.doc} for referencing it from the definition with every id
+   */
+  doc(id: Id<C>): DocumentReference<C>;
+}
+/**
+ * A typed reference to one document in a collection.
+ *
+ * **Details**
+ *
+ * It knows the {@link Collection} it was built from, so reads through it
+ * decode with that collection's model and writes encode with it. Build one
+ * with {@link Collection.doc}, {@link CollectionReference.doc} or
+ * {@link fromPath}. Two references are `Equal` when they have the same path and
+ * come from the same definition.
+ *
+ * @see {@link CollectionGroup.DocumentReference} for a reference into any collection of a group
+ * @see {@link DocumentPath.DocumentPath} for the untyped path a reference is stored as in a field
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.1.0
+ */
+export interface DocumentReference<C extends Any> extends Inspectable.Inspectable, Equal.Equal {
+  readonly [DocumentReferenceTypeId]: typeof DocumentReferenceTypeId;
+  /** The definition of the collection holding it. */
+  readonly collection: C;
+  /** The ids that address its collection, from the root down. */
+  readonly ancestors: Readonly<Ancestors<C>>;
+  /** The document's own id. */
+  readonly id: Id<C>;
+  /** The full path, such as `users/alice/posts/hello`. */
+  readonly path: string;
+  /** A reference to the collection holding it. */
+  readonly parent: CollectionReference<C>;
+}
+/**
+ * Checks whether a value is a collection definition.
+ *
+ * @see {@link isCollectionReference} for a reference to a collection
+ * @see {@link CollectionGroup.isCollectionGroup} for a Collection Group
+ *
+ * @stability unstable
+ * @category guards
+ * @since 0.1.0
+ */
+export declare const isCollection: (u: unknown) => u is Any;
+/**
+ * Checks whether a value is a {@link CollectionReference}.
+ *
+ * @see {@link isCollection} for a collection definition
+ * @see {@link isDocumentReference} for a reference to a document
+ *
+ * @stability unstable
+ * @category guards
+ * @since 0.1.0
+ */
+export declare const isCollectionReference: (u: unknown) => u is CollectionReference<Any>;
+/**
+ * Checks whether a value is a {@link DocumentReference} into any collection.
+ *
+ * @see {@link Collection.contains} for checking that a reference belongs to one collection, with narrowing
+ * @see {@link isCollectionReference} for a reference to a collection
+ * @see {@link DocumentPath.isDocumentPath} for the untyped path stored in a field
+ *
+ * @stability unstable
+ * @category guards
+ * @since 0.1.0
+ */
+export declare const isDocumentReference: (u: unknown) => u is DocumentReference<Any>;
+/**
+ * Defines a root collection and the model of its documents.
+ *
+ * **When to use**
+ *
+ * Use once per root collection, at module level, and build every reference to
+ * it from the result. Use {@link Collection.subcollection} on the result for a
+ * collection nested under its documents.
+ *
+ * **Details**
+ *
+ * The documents are described by a {@link FirestoreModel.Class} rather than a
+ * plain schema, since a document is written in other shapes than it is read
+ * in, and the model carries each of them. Pass a {@link FirestoreModel.Union}
+ * of classes for a collection that holds several document shapes.
+ *
+ * Throws when `segment` is not a collection id Firestore accepts: empty,
+ * containing `/`, `.` or `..`, matching `__.*__`, or longer than 1500 bytes. An
+ * invalid definition is a programming error, not a failure to recover from.
+ *
+ * @example Defining a collection with a subcollection
+ * ```ts
+ * import { Collection, Firestore, FirestoreModel } from "@visiolab/effect-firebase/firestore";
+ * import { Effect, Schema } from "effect";
+ *
+ * class User extends FirestoreModel.Class<User>("User")({ name: Schema.String }) {}
+ * class Post extends FirestoreModel.Class<Post>("Post")({ title: Schema.String }) {}
+ *
+ * const Users = Collection.make("users", User);
+ * const UserPosts = Users.subcollection("posts", Post);
+ *
+ * const program = Effect.gen(function* () {
+ *   const firestore = yield* Firestore.Firestore;
+ *   const alice = Users.id.make("alice");
+ *
+ *   yield* firestore.setDoc(Users.doc(alice), { name: "Alice" });
+ *   const post = yield* firestore.addDoc(UserPosts.collection(alice), { title: "Hello" });
+ *   return post.path; // "users/alice/posts/<generated id>"
+ * });
+ * ```
+ *
+ * @see {@link fromPath} for a reference to a document of an existing collection from a path string
+ * @see {@link CollectionGroup.make} for reading several collections with one collection id together
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: <const Segment extends string, S extends Any$1>(segment: Segment, schema: S) => Collection<readonly [readonly [Segment, S]]>;
+/**
+ * References the document of `collection` at a path string, such as
+ * `users/alice/posts/hello`, or returns `None` when the path is not in that
+ * collection.
+ *
+ * **When to use**
+ *
+ * Use when a path arrives as a string, such as from a URL, a message or a
+ * stored {@link DocumentPath.DocumentPath}, and you know which collection it
+ * should be in.
+ *
+ * **Details**
+ *
+ * The path is checked against every segment the collection was defined with,
+ * so a path into another collection returns `None`, even one with the same
+ * last segment. Every id in the path must be non-empty.
+ *
+ * @example Parsing a path
+ * ```ts
+ * import { Collection, FirestoreModel } from "@visiolab/effect-firebase/firestore";
+ * import { Option, Schema } from "effect";
+ *
+ * class User extends FirestoreModel.Class<User>("User")({ name: Schema.String }) {}
+ * class Post extends FirestoreModel.Class<Post>("Post")({ title: Schema.String }) {}
+ *
+ * const Users = Collection.make("users", User);
+ * const UserPosts = Users.subcollection("posts", Post);
+ *
+ * Option.isSome(Collection.fromPath(UserPosts, "users/alice/posts/hello")); // true
+ * Option.isSome(Collection.fromPath(UserPosts, "orgs/acme/posts/hello")); // false
+ * ```
+ *
+ * @see {@link Collection.doc} for a reference built from typed ids
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.2.0
+ */
+export declare const fromPath: <C extends Any>(collection: C, path: string) => Option.Option<DocumentReference<C>>;
+export { Collection_d_exports };