convex-ents 0.1.0

package/README.md

@@ -0,0 +1,8 @@
+# Convex Ents
+
+Convex Ents are an ergonomic layer on top of the Convex built-in ctx.db API for
+reading from and writing to the database. They simplify working with
+relationships between documents, allow specifying unique fields, default values
+and rules (row level security).
+
+Check out the docs: https://labs.convex.dev/convex-ents

package/dist/functions.d.ts

@@ -0,0 +1,303 @@
+import { GenericEntsDataModel } from './schema.js';
+import * as convex_values from 'convex/values';
+import { GenericId } from 'convex/values';
+import { TableNamesInDataModel, DocumentByName, FilterBuilder, NamedTableInfo, ExpressionOrValue, PaginationOptions, PaginationResult, IndexNames, FieldTypeFromFieldPath, SearchIndexNames, SearchFilterBuilder, NamedSearchIndex, SearchFilter, GenericDatabaseReader, GenericDatabaseWriter, IndexRangeBuilder, NamedIndex, IndexRange, WithoutSystemFields, WithOptionalSystemFields, GenericDocument } from 'convex/server';
+import { WithEdges, WithEdgePatches } from './writer.js';
+
+interface PromiseOrderedQueryOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[] | null> {
+    filter(predicate: (q: FilterBuilder<NamedTableInfo<EntsDataModel, Table>>) => ExpressionOrValue<boolean>): this;
+    map<TOutput>(callbackFn: (value: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>, index: number, array: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]) => Promise<TOutput> | TOutput): Promise<TOutput[] | null>;
+    paginate(paginationOpts: PaginationOptions): Promise<PaginationResult<DocumentByName<EntsDataModel, Table>> | null>;
+    take(n: number): PromiseEntsOrNull<EntsDataModel, Table>;
+    first(): PromiseEntOrNull<EntsDataModel, Table>;
+    unique(): PromiseEntOrNull<EntsDataModel, Table>;
+    docs(): Promise<DocumentByName<EntsDataModel, Table>[] | null>;
+}
+interface PromiseQueryOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends PromiseOrderedQueryOrNull<EntsDataModel, Table> {
+    order(order: "asc" | "desc", indexName?: IndexNames<NamedTableInfo<EntsDataModel, Table>>): PromiseOrderedQueryOrNull<EntsDataModel, Table>;
+}
+interface PromiseTableBase<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> {
+    getMany<Indexes extends EntsDataModel[Table]["indexes"], Index extends keyof Indexes>(indexName: Index, values: FieldTypeFromFieldPath<DocumentByName<EntsDataModel, Table>, Indexes[Index][0]>[]): PromiseEntsOrNulls<EntsDataModel, Table>;
+    getMany(ids: GenericId<Table>[]): PromiseEntsOrNulls<EntsDataModel, Table>;
+    getManyX<Indexes extends EntsDataModel[Table]["indexes"], Index extends keyof Indexes>(indexName: Index, values: FieldTypeFromFieldPath<DocumentByName<EntsDataModel, Table>, Indexes[Index][0]>[]): PromiseEnts<EntsDataModel, Table>;
+    getManyX(ids: GenericId<Table>[]): PromiseEnts<EntsDataModel, Table>;
+    /**
+     * Returns the string ID format for the ID in a given table, or null if the ID
+     * is from a different table or is not a valid ID.
+     *
+     * This does not guarantee that the ID exists (i.e. `table("foo").get(id)` may return `null`).
+     *
+     * @param tableName - The name of the table.
+     * @param id - The ID string.
+     */
+    normalizeId(id: string): GenericId<Table> | null;
+}
+interface PromiseTable<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends PromiseQuery<EntsDataModel, Table>, PromiseTableBase<EntsDataModel, Table> {
+    get<Indexes extends EntsDataModel[Table]["indexes"], Index extends keyof Indexes>(indexName: Index, value0: FieldTypeFromFieldPath<DocumentByName<EntsDataModel, Table>, Indexes[Index][0]>): PromiseEntOrNull<EntsDataModel, Table>;
+    get(id: GenericId<Table>): PromiseEntOrNull<EntsDataModel, Table>;
+    /**
+     * Fetch a document from the DB using given index, throw if it doesn't exist.
+     */
+    getX<Indexes extends EntsDataModel[Table]["indexes"], Index extends keyof Indexes>(indexName: Index, value0: FieldTypeFromFieldPath<DocumentByName<EntsDataModel, Table>, Indexes[Index][0]>): PromiseEnt<EntsDataModel, Table>;
+    /**
+     * Fetch a document from the DB for a given ID, throw if it doesn't exist.
+     */
+    getX(id: GenericId<Table>): PromiseEnt<EntsDataModel, Table>;
+    /**
+     * Query by running a full text search against a search index.
+     *
+     * Search queries must always search for some text within the index's
+     * `searchField`. This query can optionally add equality filters for any
+     * `filterFields` specified in the index.
+     *
+     * Documents will be returned in relevance order based on how well they
+     * match the search text.
+     *
+     * To learn about full text search, see [Indexes](https://docs.convex.dev/text-search).
+     *
+     * @param indexName - The name of the search index to query.
+     * @param searchFilter - A search filter expression constructed with the
+     * supplied {@link SearchFilterBuilder}. This defines the full text search to run
+     * along with equality filtering to run within the search index.
+     * @returns - A query that searches for matching documents, returning them
+     * in relevancy order.
+     */
+    search<IndexName extends SearchIndexNames<NamedTableInfo<EntsDataModel, Table>>>(indexName: IndexName, searchFilter: (q: SearchFilterBuilder<DocumentByName<EntsDataModel, Table>, NamedSearchIndex<NamedTableInfo<EntsDataModel, Table>, IndexName>>) => SearchFilter): PromiseOrderedQuery<EntsDataModel, Table>;
+}
+interface PromiseOrderedQueryBase<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> {
+    filter(predicate: (q: FilterBuilder<NamedTableInfo<EntsDataModel, Table>>) => ExpressionOrValue<boolean>): this;
+    paginate(paginationOpts: PaginationOptions): Promise<PaginationResult<DocumentByName<EntsDataModel, Table>>>;
+    first(): PromiseEntOrNull<EntsDataModel, Table>;
+    unique(): PromiseEntOrNull<EntsDataModel, Table>;
+    docs(): Promise<DocumentByName<EntsDataModel, Table>[]>;
+}
+interface PromiseOrderedQuery<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]>, PromiseOrderedQueryBase<EntsDataModel, Table> {
+    map<TOutput>(callbackFn: (value: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>, index: number, array: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]) => Promise<TOutput> | TOutput): Promise<TOutput[]>;
+    take(n: number): PromiseEnts<EntsDataModel, Table>;
+    firstX(): PromiseEnt<EntsDataModel, Table>;
+    uniqueX(): PromiseEnt<EntsDataModel, Table>;
+}
+interface PromiseQuery<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends PromiseOrderedQuery<EntsDataModel, Table> {
+    order(order: "asc" | "desc", indexName?: IndexNames<NamedTableInfo<EntsDataModel, Table>>): PromiseOrderedQuery<EntsDataModel, Table>;
+}
+interface PromiseEntsOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[] | null> {
+    map<TOutput>(callbackFn: (value: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>, index: number, array: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]) => Promise<TOutput> | TOutput): Promise<TOutput[] | null>;
+    docs(): Promise<DocumentByName<EntsDataModel, Table>[] | null>;
+}
+interface PromiseEnts<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]> {
+    map<TOutput>(callbackFn: (value: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>, index: number, array: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]) => Promise<TOutput> | TOutput): Promise<TOutput[]>;
+    docs(): Promise<DocumentByName<EntsDataModel, Table>[]>;
+}
+interface PromiseEntsOrNulls<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<(Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel> | null)[]> {
+}
+interface PromiseEdgeEntsOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends PromiseEntsOrNull<EntsDataModel, Table> {
+    /**
+     * Returns whether there is an ent with given ID on the other side
+     * the edge. Returns null if chained to a null result.
+     * @param id The ID of the ent on the other end of the edge
+     */
+    has(id: GenericId<Table>): Promise<boolean | null>;
+}
+interface PromiseEdgeEnts<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends PromiseEnts<EntsDataModel, Table> {
+    /**
+     * Returns whether there is an ent with given ID on the other side
+     * the edge.
+     * @param id The ID of the ent on the other end of the edge
+     */
+    has(id: GenericId<Table>): Promise<boolean>;
+}
+interface PromiseEntOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel> | null> {
+    edge<Edge extends keyof EntsDataModel[Table]["edges"]>(edge: Edge): PromiseEdgeOrNull<EntsDataModel, Table, Edge>;
+    doc(): Promise<DocumentByName<EntsDataModel, Table> | null>;
+}
+interface PromiseEnt<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>> {
+    edge<Edge extends keyof EntsDataModel[Table]["edges"]>(edge: Edge): PromiseEdge<EntsDataModel, Table, Edge>;
+    edgeX<Edge extends keyof EntsDataModel[Table]["edges"]>(edge: Edge): PromiseEdgeOrThrow<EntsDataModel, Table, Edge>;
+    doc(): Promise<DocumentByName<EntsDataModel, Table>>;
+}
+declare function entWrapper<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>>(fields: DocumentByName<EntsDataModel, Table>, db: GenericDatabaseReader<EntsDataModel>, entDefinitions: EntsDataModel, table: Table): Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>;
+declare function entsTableFactory<Database extends GenericDatabaseReader<any>, EntsDataModel extends GenericEntsDataModel>(db: Database, entDefinitions: EntsDataModel): Database extends GenericDatabaseWriter<any> ? EntsTableWriter<EntsDataModel> : EntsTable<EntsDataModel>;
+type EntsTable<EntsDataModel extends GenericEntsDataModel> = {
+    <Table extends TableNamesInDataModel<EntsDataModel>, IndexName extends IndexNames<NamedTableInfo<EntsDataModel, Table>>>(table: Table, indexName: IndexName, indexRange?: (q: IndexRangeBuilder<DocumentByName<EntsDataModel, Table>, NamedIndex<NamedTableInfo<EntsDataModel, Table>, IndexName>>) => IndexRange): PromiseQuery<EntsDataModel, Table>;
+    <Table extends TableNamesInDataModel<EntsDataModel>>(table: Table): PromiseTable<EntsDataModel, Table>;
+};
+type EntsTableWriter<EntsDataModel extends GenericEntsDataModel> = {
+    <Table extends TableNamesInDataModel<EntsDataModel>, IndexName extends IndexNames<NamedTableInfo<EntsDataModel, Table>>>(table: Table, indexName: IndexName, indexRange?: (q: IndexRangeBuilder<DocumentByName<EntsDataModel, Table>, NamedIndex<NamedTableInfo<EntsDataModel, Table>, IndexName>>) => IndexRange): PromiseTable<EntsDataModel, Table>;
+    <Table extends TableNamesInDataModel<EntsDataModel>>(table: Table): PromiseTableWriter<Table, EntsDataModel>;
+};
+declare class EntInstance<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> {
+    edge<Edge extends keyof EntsDataModel[Table]["edges"]>(edge: Edge): PromiseEdge<EntsDataModel, Table, Edge>;
+    edgeX<Edge extends keyof EntsDataModel[Table]["edges"]>(edge: Edge): PromiseEdgeOrThrow<EntsDataModel, Table, Edge>;
+}
+type Ent<Table extends TableNamesInDataModel<EntsDataModel>, Doc extends DocumentByName<EntsDataModel, Table>, EntsDataModel extends GenericEntsDataModel> = Doc & EntInstance<EntsDataModel, Table>;
+type GenericEnt<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> = Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>;
+type PromiseEdge<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>, Edge extends keyof EntsDataModel[Table]["edges"]> = EntsDataModel[Table]["edges"][Edge]["cardinality"] extends "multiple" ? EntsDataModel[Table]["edges"][Edge]["type"] extends "ref" ? PromiseEdgeEnts<EntsDataModel, EntsDataModel[Table]["edges"][Edge]["to"]> : PromiseQuery<EntsDataModel, EntsDataModel[Table]["edges"][Edge]["to"]> : EntsDataModel[Table]["edges"][Edge]["type"] extends "ref" ? PromiseEntOrNull<EntsDataModel, EntsDataModel[Table]["edges"][Edge]["to"]> : PromiseEnt<EntsDataModel, EntsDataModel[Table]["edges"][Edge]["to"]>;
+type PromiseEdgeOrThrow<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>, Edge extends keyof EntsDataModel[Table]["edges"]> = EntsDataModel[Table]["edges"][Edge]["cardinality"] extends "multiple" ? EntsDataModel[Table]["edges"][Edge]["type"] extends "ref" ? PromiseEdgeEnts<EntsDataModel, EntsDataModel[Table]["edges"][Edge]["to"]> : PromiseQuery<EntsDataModel, EntsDataModel[Table]["edges"][Edge]["to"]> : EntsDataModel[Table]["edges"][Edge]["type"] extends "ref" ? PromiseEnt<EntsDataModel, EntsDataModel[Table]["edges"][Edge]["to"]> : PromiseEnt<EntsDataModel, EntsDataModel[Table]["edges"][Edge]["to"]>;
+type PromiseEdgeOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>, Edge extends keyof EntsDataModel[Table]["edges"]> = EntsDataModel[Table]["edges"][Edge]["cardinality"] extends "multiple" ? EntsDataModel[Table]["edges"][Edge]["type"] extends "ref" ? PromiseEdgeEntsOrNull<EntsDataModel, EntsDataModel[Table]["edges"][Edge]["to"]> : PromiseQueryOrNull<EntsDataModel, EntsDataModel[Table]["edges"][Edge]["to"]> : PromiseEntOrNull<EntsDataModel, EntsDataModel[Table]["edges"][Edge]["to"]>;
+interface PromiseOrderedQueryWriter<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<EntWriter<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]>, PromiseOrderedQueryBase<EntsDataModel, Table> {
+    map<TOutput>(callbackFn: (value: EntWriter<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>, index: number, array: EntWriter<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>[]) => Promise<TOutput> | TOutput): Promise<TOutput[]>;
+    take(n: number): PromiseEntsWriter<EntsDataModel, Table>;
+    firstX(): PromiseEntWriter<EntsDataModel, Table>;
+    uniqueX(): PromiseEntWriter<EntsDataModel, Table>;
+}
+interface PromiseQueryWriter<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends PromiseOrderedQueryWriter<EntsDataModel, Table> {
+    order(order: "asc" | "desc", indexName?: IndexNames<NamedTableInfo<EntsDataModel, Table>>): PromiseOrderedQueryWriter<EntsDataModel, Table>;
+}
+interface PromiseEntsWriter<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends PromiseEnts<EntsDataModel, Table> {
+    firstX(): PromiseEntWriter<EntsDataModel, Table>;
+    uniqueX(): PromiseEntWriter<EntsDataModel, Table>;
+}
+interface PromiseTableWriter<Table extends TableNamesInDataModel<EntsDataModel>, EntsDataModel extends GenericEntsDataModel> extends PromiseQueryWriter<EntsDataModel, Table>, PromiseTableBase<EntsDataModel, Table> {
+    get<Indexes extends EntsDataModel[Table]["indexes"], Index extends keyof Indexes>(indexName: Index, value0: FieldTypeFromFieldPath<DocumentByName<EntsDataModel, Table>, Indexes[Index][0]>): PromiseEntWriterOrNull<EntsDataModel, Table>;
+    get(id: GenericId<Table>): PromiseEntWriterOrNull<EntsDataModel, Table>;
+    /**
+     * Fetch a document from the DB using given index, throw if it doesn't exist.
+     */
+    getX<Indexes extends EntsDataModel[Table]["indexes"], Index extends keyof Indexes>(indexName: Index, value0: FieldTypeFromFieldPath<DocumentByName<EntsDataModel, Table>, Indexes[Index][0]>): PromiseEnt<EntsDataModel, Table>;
+    /**
+     * Fetch a document from the DB for a given ID, throw if it doesn't exist.
+     */
+    getX(id: GenericId<Table>): PromiseEntWriter<EntsDataModel, Table>;
+    /**
+     * Query by running a full text search against a search index.
+     *
+     * Search queries must always search for some text within the index's
+     * `searchField`. This query can optionally add equality filters for any
+     * `filterFields` specified in the index.
+     *
+     * Documents will be returned in relevance order based on how well they
+     * match the search text.
+     *
+     * To learn about full text search, see [Indexes](https://docs.convex.dev/text-search).
+     *
+     * @param indexName - The name of the search index to query.
+     * @param searchFilter - A search filter expression constructed with the
+     * supplied {@link SearchFilterBuilder}. This defines the full text search to run
+     * along with equality filtering to run within the search index.
+     * @returns - A query that searches for matching documents, returning them
+     * in relevancy order.
+     */
+    search<IndexName extends SearchIndexNames<NamedTableInfo<EntsDataModel, Table>>>(indexName: IndexName, searchFilter: (q: SearchFilterBuilder<DocumentByName<EntsDataModel, Table>, NamedSearchIndex<NamedTableInfo<EntsDataModel, Table>, IndexName>>) => SearchFilter): PromiseOrderedQueryWriter<EntsDataModel, Table>;
+    /**
+     * Insert a new document into a table.
+     *
+     * @param table - The name of the table to insert a new document into.
+     * @param value - The {@link Value} to insert into the given table.
+     * @returns - {@link GenericId} of the new document.
+     */
+    insert(value: WithoutSystemFields<WithEdges<DocumentByName<EntsDataModel, Table>, EntsDataModel[Table]["edges"]>>): PromiseEntId<EntsDataModel, Table>;
+    /**
+     * Insert new documents into a table.
+     *
+     * @param table - The name of the table to insert a new document into.
+     * @param value - The {@link Value} to insert into the given table.
+     * @returns - {@link GenericId} of the new document.
+     */
+    insertMany(values: WithoutSystemFields<WithEdges<DocumentByName<EntsDataModel, Table>, EntsDataModel[Table]["edges"]>>[]): Promise<GenericId<Table>[]>;
+}
+interface PromiseEntWriterOrNull<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<EntWriter<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel> | null> {
+    edge<Edge extends keyof EntsDataModel[Table]["edges"]>(edge: Edge): PromiseEdgeOrNull<EntsDataModel, Table, Edge>;
+    doc(): Promise<DocumentByName<EntsDataModel, Table> | null>;
+}
+interface PromiseEntWriter<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<EntWriter<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>> {
+    edge<Edge extends keyof EntsDataModel[Table]["edges"]>(edge: Edge): PromiseEdge<EntsDataModel, Table, Edge>;
+    edgeX<Edge extends keyof EntsDataModel[Table]["edges"]>(edge: Edge): PromiseEdgeOrThrow<EntsDataModel, Table, Edge>;
+    doc(): Promise<DocumentByName<EntsDataModel, Table>>;
+    /**
+     * Patch this existing document, shallow merging it with the given partial
+     * document.
+     *
+     * New fields are added. Existing fields are overwritten. Fields set to
+     * `undefined` are removed.
+     *
+     * @param value - The partial {@link GenericDocument} to merge into this document. If this new value
+     * specifies system fields like `_id`, they must match the document's existing field values.
+     */
+    patch(value: Partial<WithEdgePatches<DocumentByName<EntsDataModel, Table>, EntsDataModel[Table]["edges"]>>): Promise<PromiseEntId<EntsDataModel, Table>>;
+    /**
+     * Replace the value of an existing document, overwriting its old value.
+     *
+     * @param value - The new {@link GenericDocument} for the document. This value can omit the system fields,
+     * and the database will preserve them in.
+     */
+    replace(value: WithOptionalSystemFields<WithEdges<DocumentByName<EntsDataModel, Table>, EntsDataModel[Table]["edges"]>>): Promise<PromiseEntId<EntsDataModel, Table>>;
+    /**
+     * Delete this existing document.
+     *
+     * @param id - The {@link GenericId} of the document to remove.
+     */
+    delete(): Promise<GenericId<Table>>;
+}
+declare class EntWriterInstance<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends EntInstance<EntsDataModel, Table> {
+    /**
+     * Patch this existing document, shallow merging it with the given partial
+     * document.
+     *
+     * New fields are added. Existing fields are overwritten. Fields set to
+     * `undefined` are removed.
+     *
+     * @param value - The partial {@link GenericDocument} to merge into this document. If this new value
+     * specifies system fields like `_id`, they must match the document's existing field values.
+     */
+    patch(value: Partial<WithEdgePatches<DocumentByName<EntsDataModel, Table>, EntsDataModel[Table]["edges"]>>): PromiseEntId<EntsDataModel, Table>;
+    /**
+     * Replace the value of this existing document, overwriting its old value.
+     *
+     * @param value - The new {@link GenericDocument} for the document. This value can omit the system fields,
+     * and the database will preserve them in.
+     */
+    replace(value: WithOptionalSystemFields<WithEdges<DocumentByName<EntsDataModel, Table>, EntsDataModel[Table]["edges"]>>): PromiseEntId<EntsDataModel, Table>;
+    /**
+     * Delete this existing document.
+     *
+     * @param id - The {@link GenericId} of the document to remove.
+     */
+    delete(): Promise<GenericId<Table>>;
+}
+type EntWriter<Table extends TableNamesInDataModel<EntsDataModel>, Doc extends DocumentByName<EntsDataModel, Table>, EntsDataModel extends GenericEntsDataModel> = Doc & EntWriterInstance<EntsDataModel, Table>;
+type GenericEntWriter<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> = EntWriter<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>;
+interface PromiseEntId<EntsDataModel extends GenericEntsDataModel, Table extends TableNamesInDataModel<EntsDataModel>> extends Promise<GenericId<Table>> {
+    get(): PromiseEntWriter<EntsDataModel, Table>;
+}
+type DocRetriever<ID, Doc> = () => Promise<{
+    id: ID;
+    doc: () => Promise<Doc>;
+}>;
+declare function addEntRules<EntsDataModel extends GenericEntsDataModel>(entDefinitions: EntsDataModel, rules: {
+    [Table in keyof EntsDataModel]?: Table extends TableNamesInDataModel<EntsDataModel> ? {
+        read?: (ent: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>) => Promise<boolean>;
+        write?: (args: {
+            operation: "create";
+            ent: undefined;
+            value: WithoutSystemFields<DocumentByName<EntsDataModel, Table>>;
+        } | {
+            operation: "update";
+            ent: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>;
+            value: Partial<WithoutSystemFields<DocumentByName<EntsDataModel, Table>>>;
+        } | {
+            operation: "delete";
+            ent: Ent<Table, DocumentByName<EntsDataModel, Table>, EntsDataModel>;
+            value: undefined;
+        }) => Promise<boolean>;
+    } : never;
+}): EntsDataModel;
+declare function getReadRule(entDefinitions: GenericEntsDataModel, table: string): ((doc: GenericDocument) => Promise<boolean>) | undefined;
+declare function getWriteRule(entDefinitions: GenericEntsDataModel, table: string): ((args: {
+    operation: "create";
+    ent: undefined;
+    value: {
+        [x: string]: convex_values.Value;
+    };
+} | {
+    operation: "update";
+    ent: Ent<any, GenericDocument, any>;
+    value: Partial<{
+        [x: string]: convex_values.Value;
+    }>;
+} | {
+    operation: "delete";
+    ent: Ent<any, GenericDocument, any>;
+    value: undefined;
+}) => Promise<boolean>) | undefined;
+
+export { type DocRetriever, type Ent, type GenericEnt, type GenericEntWriter, type PromiseEdge, type PromiseEdgeEnts, type PromiseEdgeEntsOrNull, type PromiseEdgeOrThrow, type PromiseEnt, type PromiseEntId, type PromiseEntOrNull, type PromiseEntWriter, type PromiseEntWriterOrNull, type PromiseEnts, type PromiseEntsOrNull, type PromiseEntsOrNulls, type PromiseEntsWriter, type PromiseOrderedQuery, type PromiseOrderedQueryBase, type PromiseOrderedQueryOrNull, type PromiseOrderedQueryWriter, type PromiseQuery, type PromiseQueryOrNull, type PromiseQueryWriter, type PromiseTable, type PromiseTableBase, type PromiseTableWriter, addEntRules, entWrapper, entsTableFactory, getReadRule, getWriteRule };