@xata.io/client 0.0.0-beta.f12621e → 0.0.0-beta.fddf861

package/dist/schema/query.d.ts

@@ -1,43 +1,129 @@
-import { XataRecord, Repository } from '..';
-import { Constraint, DeepConstraint, FilterConstraints, SortDirection, SortFilter } from './filters';
-import { PaginationOptions, BasePage, PaginationQueryMeta, Page } from './pagination';
-import { Selectable, SelectableColumn, Select } from './selection';
-export declare type QueryOptions<T> = {
+import { ColumnsFilter, FilterExpression, PageConfig, SortExpression } from '../api/schemas';
+import { DeepConstraint, FilterConstraints, SortDirection, SortFilter } from './filters';
+import { Page, Paginable, PaginationOptions, PaginationQueryMeta } from './pagination';
+import { XataRecord } from './record';
+import { Repository } from './repository';
+import { Select, Selectable, SelectableColumn } from './selection';
+export declare type QueryOptions<T extends XataRecord> = {
     page?: PaginationOptions;
-    columns?: Array<keyof Selectable<T>>;
+    columns?: Extract<keyof Selectable<T>, string>[];
     sort?: SortFilter<T> | SortFilter<T>[];
 };
-declare type QueryOrConstraint<T extends XataRecord, R extends XataRecord> = Query<T, R> | Constraint<T>;
-export declare class Query<T extends XataRecord, R extends XataRecord = T> implements BasePage<T, R> {
-    table: string;
-    repository: Repository<T>;
-    readonly $any?: QueryOrConstraint<T, R>[];
-    readonly $all?: QueryOrConstraint<T, R>[];
-    readonly $not?: QueryOrConstraint<T, R>[];
-    readonly $none?: QueryOrConstraint<T, R>[];
-    readonly $sort?: Record<string, SortDirection>;
-    readonly columns: SelectableColumn<T>[];
-    readonly query: Query<T, R>;
+export declare type QueryTableOptions = {
+    filter: FilterExpression;
+    sort?: SortExpression;
+    page?: PageConfig;
+    columns?: ColumnsFilter;
+};
+/**
+ * Query objects contain the information of all filters, sorting, etc. to be included in the database query.
+ *
+ * Query objects are immutable. Any method that adds more constraints or options to the query will return
+ * a new Query object containing the both the previous and the new constraints and options.
+ */
+export declare class Query<T extends XataRecord, R extends XataRecord = T> implements Paginable<T, R> {
+    #private;
     readonly meta: PaginationQueryMeta;
     readonly records: R[];
-    constructor(repository: Repository<T> | null, table: string, data: Partial<Query<T, R>>, parent?: Query<T, R>);
+    constructor(repository: Repository<T> | null, table: string, data: Partial<QueryTableOptions>, parent?: Partial<QueryTableOptions>);
+    getQueryOptions(): QueryTableOptions;
+    /**
+     * Builds a new query object representing a logical OR between the given subqueries.
+     * @param queries An array of subqueries.
+     * @returns A new Query object.
+     */
     any(...queries: Query<T, R>[]): Query<T, R>;
+    /**
+     * Builds a new query object representing a logical AND between the given subqueries.
+     * @param queries An array of subqueries.
+     * @returns A new Query object.
+     */
     all(...queries: Query<T, R>[]): Query<T, R>;
+    /**
+     * Builds a new query object representing a logical OR negating each subquery. In pseudo-code: !q1 OR !q2
+     * @param queries An array of subqueries.
+     * @returns A new Query object.
+     */
     not(...queries: Query<T, R>[]): Query<T, R>;
+    /**
+     * Builds a new query object representing a logical AND negating each subquery. In pseudo-code: !q1 AND !q2
+     * @param queries An array of subqueries.
+     * @returns A new Query object.
+     */
     none(...queries: Query<T, R>[]): Query<T, R>;
+    /**
+     * Builds a new query object adding one or more constraints. Examples:
+     *
+     * ```
+     * query.filter("columnName", columnValue)
+     * query.filter({
+     *   "columnName": columnValue
+     * })
+     * query.filter({
+     *   "columnName": operator(columnValue) // Use gt, gte, lt, lte, startsWith,...
+     * })
+     * ```
+     *
+     * @param constraints
+     * @returns A new Query object.
+     */
     filter(constraints: FilterConstraints<T>): Query<T, R>;
-    filter<F extends keyof T>(column: F, value: FilterConstraints<T[F]> | DeepConstraint<T[F]>): Query<T, R>;
+    filter<F extends keyof Selectable<T>>(column: F, value: FilterConstraints<T[F]> | DeepConstraint<T[F]>): Query<T, R>;
+    /**
+     * Builds a new query with a new sort option.
+     * @param column The column name.
+     * @param direction The direction. Either ascending or descending.
+     * @returns A new Query object.
+     */
     sort<F extends keyof T>(column: F, direction: SortDirection): Query<T, R>;
-    getPaginated<Options extends QueryOptions<T>>(options?: Options): Promise<Page<T, typeof options['columns'] extends SelectableColumn<T>[] ? Select<T, typeof options['columns'][number]> : R>>;
+    /**
+     * Builds a new query specifying the set of columns to be returned in the query response.
+     * @param columns Array of column names to be returned by the query.
+     * @returns A new Query object.
+     */
+    select<K extends SelectableColumn<T>>(columns: K[]): Query<T, Select<T, K>>;
+    getPaginated<Options extends QueryOptions<T>>(options?: Options): Promise<Page<T, GetWithColumnOptions<T, R, typeof options>>>;
     [Symbol.asyncIterator](): AsyncIterableIterator<R>;
-    getIterator(chunk: number, options?: Omit<QueryOptions<T>, 'page'>): AsyncGenerator<R[]>;
-    getMany<Options extends QueryOptions<T>>(options?: Options): Promise<(typeof options['columns'] extends SelectableColumn<T>[] ? Select<T, typeof options['columns'][number]> : R)[]>;
-    getOne<Options extends Omit<QueryOptions<T>, 'page'>>(options?: Options): Promise<(typeof options['columns'] extends SelectableColumn<T>[] ? Select<T, typeof options['columns'][number]> : R) | null>;
-    deleteAll(): Promise<number>;
+    getIterator<Options extends QueryOptions<T>>(chunk: number, options?: Omit<Options, 'page'>): AsyncGenerator<GetWithColumnOptions<T, R, typeof options>[]>;
+    /**
+     * Performs the query in the database and returns a set of results.
+     * @param options Additional options to be used when performing the query.
+     * @returns An array of records from the database.
+     */
+    getMany<Options extends QueryOptions<T>>(options?: Options): Promise<GetWithColumnOptions<T, R, typeof options>[]>;
+    /**
+     * Performs the query in the database and returns all the results.
+     * Warning: If there are a large number of results, this method can have performance implications.
+     * @param options Additional options to be used when performing the query.
+     * @returns An array of records from the database.
+     */
+    getAll<Options extends QueryOptions<T>>(chunk?: number, options?: Omit<Options, 'page'>): Promise<GetWithColumnOptions<T, R, typeof options>[]>;
+    /**
+     * Performs the query in the database and returns the first result.
+     * @param options Additional options to be used when performing the query.
+     * @returns The first record that matches the query, or null if no record matched the query.
+     */
+    getOne<Options extends Omit<QueryOptions<T>, 'page'>>(options?: Options): Promise<GetWithColumnOptions<T, R, typeof options> | null>;
+    /**async deleteAll(): Promise<number> {
+      // TODO: Return number of affected rows
+      return 0;
+    }**/
     nextPage(size?: number, offset?: number): Promise<Page<T, R>>;
     previousPage(size?: number, offset?: number): Promise<Page<T, R>>;
     firstPage(size?: number, offset?: number): Promise<Page<T, R>>;
     lastPage(size?: number, offset?: number): Promise<Page<T, R>>;
     hasNextPage(): boolean;
 }
+/**
+ * Helper type to read options and compute the correct type for the result values
+ * T: Original type
+ * R: Default destination type
+ * Options: QueryOptions
+ *
+ * If the columns are overriden in the options, the result type is the pick of the original type and the columns
+ * If the columns are not overriden, the result type is the default destination type
+ */
+declare type GetWithColumnOptions<T, R, Options> = Options extends {
+    columns: SelectableColumn<T>[];
+} ? Select<T, Options['columns'][number]> : R;
 export {};

package/dist/schema/query.js

@@ -8,6 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var __asyncValues = (this && this.__asyncValues) || function (o) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
     var m = o[Symbol.asyncIterator], i;
@@ -27,32 +38,39 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar
     function reject(value) { resume("throw", value); }
     function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
 };
+var _Query_table, _Query_repository, _Query_data;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Query = void 0;
+const lang_1 = require("../util/lang");
+const pagination_1 = require("./pagination");
+/**
+ * Query objects contain the information of all filters, sorting, etc. to be included in the database query.
+ *
+ * Query objects are immutable. Any method that adds more constraints or options to the query will return
+ * a new Query object containing the both the previous and the new constraints and options.
+ */
 class Query {
     constructor(repository, table, data, parent) {
-        this.columns = ['*'];
-        // Cursor pagination
-        this.query = this;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        _Query_table.set(this, void 0);
+        _Query_repository.set(this, void 0);
+        _Query_data.set(this, { filter: {} });
+        // Implements pagination
         this.meta = { page: { cursor: 'start', more: true } };
         this.records = [];
+        __classPrivateFieldSet(this, _Query_table, table, "f");
         if (repository) {
-            this.repository = repository;
+            __classPrivateFieldSet(this, _Query_repository, repository, "f");
         }
         else {
-            this.repository = this;
+            __classPrivateFieldSet(this, _Query_repository, this, "f");
         }
-        this.table = table;
-        // For some reason Object.assign(this, parent) didn't work in this case
-        // so doing all this manually:
-        this.$any = parent === null || parent === void 0 ? void 0 : parent.$any;
-        this.$all = parent === null || parent === void 0 ? void 0 : parent.$all;
-        this.$not = parent === null || parent === void 0 ? void 0 : parent.$not;
-        this.$none = parent === null || parent === void 0 ? void 0 : parent.$none;
-        this.$sort = parent === null || parent === void 0 ? void 0 : parent.$sort;
-        Object.assign(this, data);
-        // These bindings are used to support deconstructing
-        // const { any, not, filter, sort } = xata.users.query()
+        __classPrivateFieldGet(this, _Query_data, "f").filter.$any = (_b = (_a = data.filter) === null || _a === void 0 ? void 0 : _a.$any) !== null && _b !== void 0 ? _b : (_c = parent === null || parent === void 0 ? void 0 : parent.filter) === null || _c === void 0 ? void 0 : _c.$any;
+        __classPrivateFieldGet(this, _Query_data, "f").filter.$all = (_e = (_d = data.filter) === null || _d === void 0 ? void 0 : _d.$all) !== null && _e !== void 0 ? _e : (_f = parent === null || parent === void 0 ? void 0 : parent.filter) === null || _f === void 0 ? void 0 : _f.$all;
+        __classPrivateFieldGet(this, _Query_data, "f").filter.$not = (_h = (_g = data.filter) === null || _g === void 0 ? void 0 : _g.$not) !== null && _h !== void 0 ? _h : (_j = parent === null || parent === void 0 ? void 0 : parent.filter) === null || _j === void 0 ? void 0 : _j.$not;
+        __classPrivateFieldGet(this, _Query_data, "f").filter.$none = (_l = (_k = data.filter) === null || _k === void 0 ? void 0 : _k.$none) !== null && _l !== void 0 ? _l : (_m = parent === null || parent === void 0 ? void 0 : parent.filter) === null || _m === void 0 ? void 0 : _m.$none;
+        __classPrivateFieldGet(this, _Query_data, "f").sort = (_o = data.sort) !== null && _o !== void 0 ? _o : parent === null || parent === void 0 ? void 0 : parent.sort;
+        __classPrivateFieldGet(this, _Query_data, "f").columns = (_q = (_p = data.columns) !== null && _p !== void 0 ? _p : parent === null || parent === void 0 ? void 0 : parent.columns) !== null && _q !== void 0 ? _q : ['*'];
         this.any = this.any.bind(this);
         this.all = this.all.bind(this);
         this.not = this.not.bind(this);
@@ -62,58 +80,80 @@ class Query {
         Object.defineProperty(this, 'table', { enumerable: false });
         Object.defineProperty(this, 'repository', { enumerable: false });
     }
-    any(...queries) {
-        return new Query(this.repository, this.table, {
-            $any: (this.$any || []).concat(queries)
-        }, this);
+    getQueryOptions() {
+        return __classPrivateFieldGet(this, _Query_data, "f");
     }
+    /**
+     * Builds a new query object representing a logical OR between the given subqueries.
+     * @param queries An array of subqueries.
+     * @returns A new Query object.
+     */
+    any(...queries) {
+        const $any = queries.map((query) => query.getQueryOptions().filter);
+        return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { filter: { $any } }, __classPrivateFieldGet(this, _Query_data, "f"));
+    }
+    /**
+     * Builds a new query object representing a logical AND between the given subqueries.
+     * @param queries An array of subqueries.
+     * @returns A new Query object.
+     */
     all(...queries) {
-        return new Query(this.repository, this.table, {
-            $all: (this.$all || []).concat(queries)
-        }, this);
-    }
+        const $all = queries.map((query) => query.getQueryOptions().filter);
+        return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { filter: { $all } }, __classPrivateFieldGet(this, _Query_data, "f"));
+    }
+    /**
+     * Builds a new query object representing a logical OR negating each subquery. In pseudo-code: !q1 OR !q2
+     * @param queries An array of subqueries.
+     * @returns A new Query object.
+     */
     not(...queries) {
-        return new Query(this.repository, this.table, {
-            $not: (this.$not || []).concat(queries)
-        }, this);
-    }
+        const $not = queries.map((query) => query.getQueryOptions().filter);
+        return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { filter: { $not } }, __classPrivateFieldGet(this, _Query_data, "f"));
+    }
+    /**
+     * Builds a new query object representing a logical AND negating each subquery. In pseudo-code: !q1 AND !q2
+     * @param queries An array of subqueries.
+     * @returns A new Query object.
+     */
     none(...queries) {
-        return new Query(this.repository, this.table, {
-            $none: (this.$none || []).concat(queries)
-        }, this);
+        const $none = queries.map((query) => query.getQueryOptions().filter);
+        return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { filter: { $none } }, __classPrivateFieldGet(this, _Query_data, "f"));
     }
     filter(a, b) {
         if (arguments.length === 1) {
-            const constraints = a;
-            const queries = [];
-            for (const [column, constraint] of Object.entries(constraints)) {
-                queries.push({ [column]: constraint });
-            }
-            return new Query(this.repository, this.table, {
-                $all: (this.$all || []).concat(queries)
-            }, this);
+            const constraints = Object.entries(a).map(([column, constraint]) => ({ [column]: constraint }));
+            const $all = (0, lang_1.compact)([__classPrivateFieldGet(this, _Query_data, "f").filter.$all].flat().concat(constraints));
+            return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { filter: { $all } }, __classPrivateFieldGet(this, _Query_data, "f"));
         }
         else {
             const column = a;
             const value = b;
-            return new Query(this.repository, this.table, {
-                $all: (this.$all || []).concat({ [column]: value })
-            }, this);
+            const $all = (0, lang_1.compact)([__classPrivateFieldGet(this, _Query_data, "f").filter.$all].flat().concat({ [column]: value }));
+            return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { filter: { $all } }, __classPrivateFieldGet(this, _Query_data, "f"));
         }
     }
+    /**
+     * Builds a new query with a new sort option.
+     * @param column The column name.
+     * @param direction The direction. Either ascending or descending.
+     * @returns A new Query object.
+     */
     sort(column, direction) {
-        const sort = Object.assign(Object.assign({}, this.$sort), { [column]: direction });
-        const q = new Query(this.repository, this.table, {
-            $sort: sort
-        }, this);
-        return q;
+        const sort = Object.assign(Object.assign({}, __classPrivateFieldGet(this, _Query_data, "f").sort), { [column]: direction });
+        return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { sort }, __classPrivateFieldGet(this, _Query_data, "f"));
+    }
+    /**
+     * Builds a new query specifying the set of columns to be returned in the query response.
+     * @param columns Array of column names to be returned by the query.
+     * @returns A new Query object.
+     */
+    select(columns) {
+        return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { columns }, __classPrivateFieldGet(this, _Query_data, "f"));
     }
     getPaginated(options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.repository._runQuery(this, options);
-        });
+        return __classPrivateFieldGet(this, _Query_repository, "f").query(this, options);
     }
-    [Symbol.asyncIterator]() {
+    [(_Query_table = new WeakMap(), _Query_repository = new WeakMap(), _Query_data = new WeakMap(), Symbol.asyncIterator)]() {
         return __asyncGenerator(this, arguments, function* _a() {
             var e_1, _b;
             try {
@@ -143,43 +183,69 @@ class Query {
             }
         });
     }
+    /**
+     * Performs the query in the database and returns a set of results.
+     * @param options Additional options to be used when performing the query.
+     * @returns An array of records from the database.
+     */
     getMany(options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             const { records } = yield this.getPaginated(options);
             return records;
         });
     }
-    getOne(options = {}) {
+    /**
+     * Performs the query in the database and returns all the results.
+     * Warning: If there are a large number of results, this method can have performance implications.
+     * @param options Additional options to be used when performing the query.
+     * @returns An array of records from the database.
+     */
+    getAll(chunk = pagination_1.PAGINATION_MAX_SIZE, options = {}) {
+        var e_2, _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const records = yield this.getMany(Object.assign(Object.assign({}, options), { page: { size: 1 } }));
-            return records[0] || null;
+            const results = [];
+            try {
+                for (var _b = __asyncValues(this.getIterator(chunk, options)), _c; _c = yield _b.next(), !_c.done;) {
+                    const page = _c.value;
+                    results.push(...page);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return results;
         });
     }
-    deleteAll() {
+    /**
+     * Performs the query in the database and returns the first result.
+     * @param options Additional options to be used when performing the query.
+     * @returns The first record that matches the query, or null if no record matched the query.
+     */
+    getOne(options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            // TODO: Return number of affected rows
-            return 0;
+            const records = yield this.getMany(Object.assign(Object.assign({}, options), { page: { size: 1 } }));
+            return records[0] || null;
         });
     }
+    /**async deleteAll(): Promise<number> {
+      // TODO: Return number of affected rows
+      return 0;
+    }**/
     nextPage(size, offset) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.firstPage(size, offset);
-        });
+        return this.firstPage(size, offset);
     }
     previousPage(size, offset) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.firstPage(size, offset);
-        });
+        return this.firstPage(size, offset);
     }
     firstPage(size, offset) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.getPaginated({ page: { size, offset } });
-        });
+        return this.getPaginated({ page: { size, offset } });
     }
     lastPage(size, offset) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.getPaginated({ page: { size, offset, before: 'end' } });
-        });
+        return this.getPaginated({ page: { size, offset, before: 'end' } });
     }
     hasNextPage() {
         return this.meta.page.more;

package/dist/schema/record.d.ts

@@ -0,0 +1,44 @@
+import { Selectable } from './selection';
+/**
+ * Represents an identifiable record from the database.
+ */
+export interface Identifiable {
+    /**
+     * Unique id of this record.
+     */
+    id: string;
+}
+export interface BaseData {
+    [key: string]: any;
+}
+/**
+ * Represents a persisted record from the database.
+ */
+export interface XataRecord extends Identifiable {
+    /**
+     * Metadata of this record.
+     */
+    xata: {
+        /**
+         * Number that is increased every time the record is updated.
+         */
+        version: number;
+    };
+    /**
+     * Retrieves a refreshed copy of the current record from the database.
+     */
+    read(): Promise<this>;
+    /**
+     * Performs a partial update of the current record. On success a new object is
+     * returned and the current object is not mutated.
+     * @param data The columns and their values that have to be updated.
+     * @returns A new record containing the latest values for all the columns of the current record.
+     */
+    update(data: Partial<Selectable<this>>): Promise<this>;
+    /**
+     * Performs a deletion of the current record in the database.
+     *
+     * @throws If the record was already deleted or if an error happened while performing the deletion.
+     */
+    delete(): Promise<void>;
+}

package/dist/schema/record.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/schema/repository.d.ts

@@ -0,0 +1,104 @@
+import { FetchImpl } from '../api/fetcher';
+import { Page } from './pagination';
+import { Query, QueryOptions } from './query';
+import { BaseData, XataRecord } from './record';
+import { Select, SelectableColumn } from './selection';
+export declare type Links = Record<string, Array<string[]>>;
+/**
+ * Common interface for performing operations on a table.
+ */
+export declare abstract class Repository<Data extends BaseData, Record extends XataRecord = Data & XataRecord> extends Query<Record> {
+    abstract create(object: Data): Promise<Record>;
+    /**
+     * Creates multiple records in the table.
+     * @param objects Array of objects with the column names and the values to be stored in the table.
+     * @returns Array of the persisted records.
+     */
+    abstract createMany(objects: Data[]): Promise<Record[]>;
+    /**
+     * Queries a single record from the table given its unique id.
+     * @param id The unique id.
+     * @returns The persisted record for the given id or null if the record could not be found.
+     */
+    abstract read(id: string): Promise<Record | null>;
+    /**
+     * Insert a single record with a unique id.
+     * @param id The unique id.
+     * @param object Object containing the column names with their values to be stored in the table.
+     * @returns The full persisted record.
+     */
+    abstract insert(id: string, object: Data): Promise<Record>;
+    /**
+     * Partially update a single record given its unique id.
+     * @param id The unique id.
+     * @param object The column names and their values that have to be updatd.
+     * @returns The full persisted record.
+     */
+    abstract update(id: string, object: Partial<Data>): Promise<Record>;
+    /**
+     * Updates or inserts a single record. If a record exists with the given id,
+     * it will be update, otherwise a new record will be created.
+     * @param id A unique id.
+     * @param object The column names and the values to be persisted.
+     * @returns The full persisted record.
+     */
+    abstract updateOrInsert(id: string, object: Data): Promise<Record>;
+    /**
+     * Deletes a record given its unique id.
+     * @param id The unique id.
+     * @throws If the record could not be found or there was an error while performing the deletion.
+     */
+    abstract delete(id: string): void;
+    abstract query<Result extends XataRecord, Options extends QueryOptions<Record>>(query: Query<Record, Result>, options: Options): Promise<Page<Record, typeof options extends {
+        columns: SelectableColumn<Data>[];
+    } ? Select<Data, typeof options['columns'][number]> : Result>>;
+}
+export declare class RestRepository<Data extends BaseData, Record extends XataRecord = Data & XataRecord> extends Repository<Data, Record> {
+    #private;
+    constructor(client: BaseClient<any>, table: string);
+    create(object: Data): Promise<Record>;
+    createMany(objects: Data[]): Promise<Record[]>;
+    read(recordId: string): Promise<Record | null>;
+    update(recordId: string, object: Partial<Data>): Promise<Record>;
+    insert(recordId: string, object: Data): Promise<Record>;
+    updateOrInsert(recordId: string, object: Data): Promise<Record>;
+    delete(recordId: string): Promise<void>;
+    query<Result extends XataRecord, Options extends QueryOptions<Record>>(query: Query<Record, Result>, options?: Options): Promise<Page<Record, typeof options extends {
+        columns: SelectableColumn<Data>[];
+    } ? Select<Data, typeof options['columns'][number]> : Result>>;
+}
+interface RepositoryFactory {
+    createRepository<Data extends BaseData>(client: BaseClient<any>, table: string): Repository<Data>;
+}
+export declare class RestRespositoryFactory implements RepositoryFactory {
+    createRepository<Data extends BaseData>(client: BaseClient<any>, table: string): Repository<Data>;
+}
+declare type BranchStrategyValue = string | undefined | null;
+declare type BranchStrategyBuilder = () => BranchStrategyValue | Promise<BranchStrategyValue>;
+declare type BranchStrategy = BranchStrategyValue | BranchStrategyBuilder;
+declare type BranchStrategyOption = NonNullable<BranchStrategy | BranchStrategy[]>;
+export declare type XataClientOptions = {
+    /**
+     * Fetch implementation. This option is only required if the runtime does not include a fetch implementation
+     * available in the global scope. If you are running your code on Deno or Cloudflare workers for example,
+     * you won't need to provide a specific fetch implementation. But for most versions of Node.js you'll need
+     * to provide one. Such as cross-fetch, node-fetch or isomorphic-fetch.
+     */
+    fetch?: FetchImpl;
+    databaseURL?: string;
+    branch: BranchStrategyOption;
+    /**
+     * API key to be used. You can create one in your account settings at https://app.xata.io/settings.
+     */
+    apiKey: string;
+    repositoryFactory?: RepositoryFactory;
+};
+export declare class BaseClient<D extends Record<string, Repository<any>> = Record<string, Repository<any>>> {
+    #private;
+    options: XataClientOptions;
+    db: D;
+    constructor(options: XataClientOptions, links?: Links);
+    initObject<T>(table: string, object: object): T;
+    getBranch(): Promise<string>;
+}
+export {};