@xata.io/client 0.0.0-beta.9d62fb3 → 0.0.0-beta.bdce130

package/dist/api/fetcher.d.ts

@@ -0,0 +1,24 @@
+export declare type FetchImpl = (url: string, init?: {
+    body?: string;
+    headers?: Record<string, string>;
+    method?: string;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    json(): Promise<any>;
+}>;
+export declare type FetcherExtraProps = {
+    apiUrl: string;
+    workspacesApiUrl: string;
+    fetchImpl: FetchImpl;
+    apiKey: string;
+};
+export declare type FetcherOptions<TBody, THeaders, TQueryParams, TPathParams> = {
+    url: string;
+    method: string;
+    body?: TBody;
+    headers?: THeaders;
+    queryParams?: TQueryParams;
+    pathParams?: TPathParams;
+};
+export declare function fetch<TData, TBody extends Record<string, unknown> | undefined, THeaders extends Record<string, unknown>, TQueryParams extends Record<string, unknown>, TPathParams extends Record<string, string>>({ url, method, body, headers, pathParams, queryParams, fetchImpl, apiKey, apiUrl, workspacesApiUrl }: FetcherOptions<TBody, THeaders, TQueryParams, TPathParams> & FetcherExtraProps): Promise<TData>;

package/dist/api/fetcher.js

@@ -0,0 +1,75 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetch = void 0;
+const resolveUrl = (url, queryParams = {}, pathParams = {}) => {
+    const query = new URLSearchParams(queryParams).toString();
+    const queryString = query.length > 0 ? `?${query}` : '';
+    return url.replace(/\{\w*\}/g, (key) => pathParams[key.slice(1, -1)]) + queryString;
+};
+const fallbackError = { message: 'Network response was not ok' };
+function baseURLForWorkspace(workspacesApiUrl, workspace) {
+    // Node.js on localhost won't resolve localhost subdomains unless mapped in /etc/hosts
+    // So, instead, we use localhost without subdomains, but will add a Host header
+    if (typeof window === 'undefined' && workspacesApiUrl.includes('localhost:')) {
+        return workspacesApiUrl.replace('{workspaceId}.', '');
+    }
+    return workspacesApiUrl.replace('{workspaceId}', workspace);
+}
+function hostHeaderForWorkspace(workspacesApiUrl, workspace) {
+    const url = baseURLForWorkspace(workspacesApiUrl, workspace);
+    if (!url)
+        return;
+    const [, hostname] = url.split('://');
+    return hostname;
+}
+function fetch({ url, method, body, headers, pathParams, queryParams, fetchImpl, apiKey, apiUrl, workspacesApiUrl }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const baseURL = (pathParams === null || pathParams === void 0 ? void 0 : pathParams.workspace) ? baseURLForWorkspace(workspacesApiUrl, pathParams.workspace) : apiUrl;
+        const response = yield fetchImpl(`${baseURL}${resolveUrl(url, queryParams, pathParams)}`, {
+            method: method.toUpperCase(),
+            body: body ? JSON.stringify(body) : undefined,
+            headers: Object.assign(Object.assign(Object.assign({ 'Content-Type': 'application/json' }, headers), { Authorization: `Bearer ${apiKey}` }), ((pathParams === null || pathParams === void 0 ? void 0 : pathParams.workspace) ? { Host: hostHeaderForWorkspace(workspacesApiUrl, pathParams.workspace) } : {}))
+        });
+        // No content
+        if (response.status === 204) {
+            return {};
+        }
+        try {
+            const jsonResponse = yield response.json();
+            if (response.ok) {
+                return jsonResponse;
+            }
+            if (jsonResponse.message) {
+                throw withStatus({ message: jsonResponse.message }, response.status);
+            }
+            else {
+                throw withStatus(fallbackError, response.status);
+            }
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                const error = {
+                    message: e.message
+                };
+                throw withStatus(error, response.status);
+            }
+            else if (typeof e === 'object' && typeof e.message === 'string') {
+                throw withStatus(e, response.status);
+            }
+            else {
+                throw withStatus(fallbackError, response.status);
+            }
+        }
+    });
+}
+exports.fetch = fetch;
+const withStatus = (error, status) => (Object.assign(Object.assign({}, error), { status }));

package/dist/api/index.d.ts

@@ -0,0 +1,7 @@
+import { operationsByTag } from './components';
+import type * as Responses from './responses';
+import type * as Schemas from './schemas';
+export * from './client';
+export * from './components';
+export { operationsByTag as Operations };
+export type { Responses, Schemas };

package/dist/api/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Operations = void 0;
+const components_1 = require("./components");
+Object.defineProperty(exports, "Operations", { enumerable: true, get: function () { return components_1.operationsByTag; } });
+__exportStar(require("./client"), exports);
+__exportStar(require("./components"), exports);

package/dist/api/parameters.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Generated by @openapi-codegen
+ *
+ * @version 1.0
+ */
+import type * as Schemas from './schemas';
+export declare type APIKeyNameParam = Schemas.APIKeyName;
+export declare type InviteIDParam = Schemas.InviteID;
+export declare type InviteKeyParam = Schemas.InviteKey;
+export declare type UserIDParam = Schemas.UserID;
+export declare type WorkspaceIDParam = Schemas.WorkspaceID;
+export declare type ColumnNameParam = Schemas.ColumnName;
+export declare type DBBranchNameParam = Schemas.DBBranchName;
+export declare type DBNameParam = Schemas.DBName;
+export declare type RecordIDParam = Schemas.RecordID;
+export declare type TableNameParam = Schemas.TableName;

package/dist/api/parameters.js

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

package/dist/api/providers.d.ts

@@ -0,0 +1,8 @@
+declare type HostAliases = 'production' | 'staging';
+declare type ProviderBuilder = {
+    main: string;
+    workspaces: string;
+};
+export declare type HostProvider = HostAliases | ProviderBuilder;
+export declare function getHostUrl(provider: HostProvider, type: keyof ProviderBuilder): string;
+export {};

package/dist/api/providers.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHostUrl = void 0;
+function getHostUrl(provider, type) {
+    if (isValidAlias(provider)) {
+        return providers[provider][type];
+    }
+    else if (isValidBuilder(provider)) {
+        return provider[type];
+    }
+    throw new Error('Invalid API provider');
+}
+exports.getHostUrl = getHostUrl;
+const providers = {
+    production: {
+        main: 'https://api.xata.io',
+        workspaces: 'https://{workspaceId}.xata.sh'
+    },
+    staging: {
+        main: 'https://staging.xatabase.co',
+        workspaces: 'https://{workspaceId}.staging.xatabase.co'
+    }
+};
+function isValidAlias(alias) {
+    return typeof alias === 'string' && Object.keys(providers).includes(alias);
+}
+function isValidBuilder(builder) {
+    return typeof builder === 'object' && typeof builder.main === 'string' && typeof builder.workspaces === 'string';
+}

package/dist/api/responses.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Generated by @openapi-codegen
+ *
+ * @version 1.0
+ */
+import type * as Schemas from './schemas';
+export declare type SimpleError = {
+    id?: string;
+    message: string;
+};
+export declare type BadRequestError = {
+    id?: string;
+    message: string;
+};
+/**
+ * @example {"message":"invalid API key"}
+ */
+export declare type AuthError = {
+    id?: string;
+    message: string;
+};
+export declare type BranchMigrationPlan = {
+    version: number;
+    migration: Schemas.BranchMigration;
+};
+export declare type QueryResponse = {
+    records: Schemas.XataRecord[];
+    meta: Schemas.RecordsMetadata;
+};
+export declare type SearchResponse = {
+    records: Schemas.XataRecord[];
+};
+/**
+ * @example {"migrationID":"mig_c7m19ilcefoebpqj12p0"}
+ */
+export declare type MigrationIdResponse = {
+    migrationID: string;
+};

package/dist/api/responses.js

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

package/dist/api/schemas.d.ts

@@ -0,0 +1,311 @@
+/**
+ * Generated by @openapi-codegen
+ *
+ * @version 1.0
+ */
+export declare type User = {
+    email: string;
+    fullname: string;
+    image: string;
+};
+/**
+ * @pattern [a-zA-Z0-9_-~:]+
+ */
+export declare type UserID = string;
+export declare type UserWithID = User & {
+    id: UserID;
+};
+/**
+ * @format date-time
+ * @x-go-type string
+ */
+export declare type DateTime = string;
+/**
+ * @pattern [a-zA-Z0-9_\-~]*
+ */
+export declare type APIKeyName = string;
+/**
+ * @pattern ^([a-zA-Z0-9][a-zA-Z0-9_\-~]+-)?[a-zA-Z0-9]{6}
+ * @x-go-type auth.WorkspaceID
+ */
+export declare type WorkspaceID = string;
+/**
+ * @x-go-type auth.Role
+ */
+export declare type Role = 'owner' | 'maintainer';
+export declare type WorkspaceMeta = {
+    name: string;
+    slug: string;
+};
+export declare type Workspace = WorkspaceMeta & {
+    id: WorkspaceID;
+    memberCount: number;
+    plan: 'free';
+};
+export declare type WorkspaceMember = {
+    userId: UserID;
+    fullname: string;
+    email: string;
+    role: Role;
+};
+/**
+ * @pattern [a-zA-Z0-9]+
+ */
+export declare type InviteID = string;
+export declare type WorkspaceInvite = {
+    inviteId: InviteID;
+    email: string;
+    expires: string;
+    role: Role;
+};
+export declare type WorkspaceMembers = {
+    members: WorkspaceMember[];
+    invites: WorkspaceInvite[];
+};
+/**
+ * @pattern ^ik_[a-zA-Z0-9]+
+ */
+export declare type InviteKey = string;
+export declare type ListDatabasesResponse = {
+    databases?: {
+        name: string;
+        displayName: string;
+        createdAt: DateTime;
+        numberOfBranches: number;
+        ui?: {
+            color?: string;
+        };
+    }[];
+};
+export declare type ListBranchesResponse = {
+    databaseName: string;
+    displayName: string;
+    branches: Branch[];
+};
+export declare type Branch = {
+    name: string;
+    createdAt: DateTime;
+};
+/**
+ * @example {"repository":"github.com/my/repository","branch":"feature-login","stage":"testing","labels":["epic-100"]}
+ * @x-go-type xata.BranchMetadata
+ */
+export declare type BranchMetadata = {
+    repository?: string;
+    branch?: BranchName;
+    stage?: string;
+    labels?: string[];
+};
+export declare type DBBranch = {
+    databaseName: DBName;
+    branchName: BranchName;
+    createdAt: DateTime;
+    id: string;
+    version: number;
+    lastMigrationID: string;
+    metadata?: BranchMetadata;
+    startedFrom?: StartedFromMetadata;
+    schema: Schema;
+};
+export declare type StartedFromMetadata = {
+    branchName: BranchName;
+    dbBranchID: string;
+    migrationID: string;
+};
+/**
+ * @x-go-type xata.Schema
+ */
+export declare type Schema = {
+    tables: Table[];
+    tablesOrder?: string[];
+};
+export declare type Table = {
+    id?: string;
+    name: TableName;
+    columns: Column[];
+    revLinks?: RevLink[];
+};
+/**
+ * @x-go-type xata.Column
+ */
+export declare type Column = {
+    name: string;
+    type: 'bool' | 'int' | 'float' | 'string' | 'text' | 'email' | 'multiple' | 'link' | 'object';
+    link?: {
+        table: string;
+    };
+    columns?: Column[];
+};
+export declare type RevLink = {
+    linkID: string;
+    table: string;
+};
+/**
+ * @pattern [a-zA-Z0-9_\-~]+
+ */
+export declare type BranchName = string;
+/**
+ * @pattern [a-zA-Z0-9_\-~]+
+ */
+export declare type DBName = string;
+/**
+ * The DBBranchName matches the pattern `{db_name}:{branch_name}`.
+ *
+ * @pattern [a-zA-Z0-9_\-~]+:[a-zA-Z0-9_\-~]+
+ */
+export declare type DBBranchName = string;
+/**
+ * @pattern [a-zA-Z0-9_\-~]+
+ */
+export declare type TableName = string;
+/**
+ * @pattern [a-zA-Z0-9_\-~\.]+
+ */
+export declare type ColumnName = string;
+export declare type MetricsDatapoint = {
+    timestamp: string;
+    value: number;
+};
+export declare type MetricsLatency = {
+    p50?: MetricsDatapoint[];
+    p90?: MetricsDatapoint[];
+};
+export declare type BranchMigration = {
+    id?: string;
+    parentID?: string;
+    status: string;
+    title?: string;
+    lastGitRevision?: string;
+    localChanges: boolean;
+    createdAt?: DateTime;
+    newTables?: {
+        [key: string]: Table;
+    };
+    removedTables?: string[];
+    tableMigrations?: {
+        [key: string]: TableMigration;
+    };
+    newTableOrder: string[];
+    renamedTables?: TableRename[];
+};
+export declare type TableMigration = {
+    newColumns?: {
+        [key: string]: Column;
+    };
+    removedColumns?: string[];
+    modifiedColumns?: ColumnMigration[];
+    newColumnOrder: string[];
+};
+export declare type ColumnMigration = {
+    old: Column;
+    ['new']: Column;
+};
+export declare type SortExpression = string[] | {
+    [key: string]: SortOrder;
+} | {
+    [key: string]: SortOrder;
+}[];
+export declare type SortOrder = 'asc' | 'desc';
+/**
+ * @minProperties 1
+ */
+export declare type FilterExpression = {
+    $exists?: string;
+    $existsNot?: string;
+    $any?: FilterList;
+    $all?: FilterList;
+    $none?: FilterList;
+    $not?: FilterList;
+} & {
+    [key: string]: FilterColumn;
+};
+export declare type FilterList = FilterExpression | FilterExpression[];
+export declare type FilterColumn = FilterColumnIncludes | FilterPredicate | FilterList;
+/**
+ * @maxProperties 1
+ * @minProperties 1
+ */
+export declare type FilterColumnIncludes = {
+    $includes?: FilterPredicate;
+    $includesAny?: FilterPredicate;
+    $includesAll?: FilterPredicate;
+    $includesNone?: FilterPredicate;
+};
+export declare type FilterPredicate = FilterValue | FilterPredicate[] | FilterPredicateOp | FilterPredicateRangeOp;
+/**
+ * @maxProperties 1
+ * @minProperties 1
+ */
+export declare type FilterPredicateOp = {
+    $any?: FilterPredicate[];
+    $all?: FilterPredicate[];
+    $none?: FilterPredicate | FilterPredicate[];
+    $not?: FilterPredicate | FilterPredicate[];
+    $is?: FilterValue | FilterValue[];
+    $isNot?: FilterValue | FilterValue[];
+    $lt?: FilterRangeValue;
+    $le?: FilterRangeValue;
+    $gt?: FilterRangeValue;
+    $ge?: FilterRangeValue;
+    $contains?: string;
+    $startsWith?: string;
+    $endsWith?: string;
+    $pattern?: string;
+};
+/**
+ * @maxProperties 2
+ * @minProperties 2
+ */
+export declare type FilterPredicateRangeOp = {
+    $lt?: FilterRangeValue;
+    $le?: FilterRangeValue;
+    $gt?: FilterRangeValue;
+    $ge?: FilterRangeValue;
+};
+export declare type FilterRangeValue = number | string;
+export declare type FilterValue = number | string | boolean;
+/**
+ * Pagination settings.
+ */
+export declare type PageConfig = {
+    after?: string;
+    before?: string;
+    first?: string;
+    last?: string;
+    size?: number;
+    offset?: number;
+};
+export declare type ColumnsFilter = string[];
+/**
+ * @pattern [a-zA-Z0-9_-~:]+
+ */
+export declare type RecordID = string;
+/**
+ * @example {"newName":"newName","oldName":"oldName"}
+ */
+export declare type TableRename = {
+    newName: string;
+    oldName: string;
+};
+/**
+ * Records metadata
+ */
+export declare type RecordsMetadata = {
+    page: {
+        cursor: string;
+        more: boolean;
+    };
+};
+/**
+ * Xata Table Record
+ */
+export declare type XataRecord = {
+    id: RecordID;
+    xata: {
+        version: number;
+        table?: string;
+        warnings?: string[];
+    };
+} & {
+    [key: string]: any;
+};

package/dist/api/schemas.js

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

package/dist/index.d.ts

@@ -1,3 +1,6 @@
+import { Page } from './schema/pagination';
+import { Query, QueryOptions } from './schema/query';
+import { Selectable, SelectableColumn, Select } from './schema/selection';
 export interface XataRecord {
     id: string;
     xata: {
@@ -7,107 +10,30 @@ export interface XataRecord {
     update(data: Selectable<this>): Promise<this>;
     delete(): Promise<void>;
 }
-export declare type Queries<T> = {
-    [key in keyof T as T[key] extends Query<infer A, infer B> ? key : never]: T[key];
-};
-export declare type OmitQueries<T> = {
-    [key in keyof T as T[key] extends Query<infer A, infer B> ? never : key]: T[key];
-};
-export declare type OmitLinks<T> = {
-    [key in keyof T as T[key] extends XataRecord ? never : key]: T[key];
-};
-export declare type OmitMethods<T> = {
-    [key in keyof T as T[key] extends Function ? never : key]: T[key];
-};
-export declare type Selectable<T> = Omit<OmitQueries<OmitMethods<T>>, 'id' | 'xata'>;
-export declare type Select<T, K extends keyof T> = Pick<T, K> & Queries<T> & XataRecord;
-export declare type Include<T> = {
-    [key in keyof T as T[key] extends XataRecord ? key : never]?: boolean | Array<keyof Selectable<T[key]>>;
-};
-declare type SortDirection = 'asc' | 'desc';
-declare type Operator = '$gt' | '$lt' | '$ge' | '$le' | '$exists' | '$notExists' | '$endsWith' | '$startsWith' | '$pattern' | '$is' | '$isNot' | '$contains' | '$includes' | '$includesSubstring' | '$includesPattern' | '$includesAll';
-declare type Constraint<T> = {
-    [key in Operator]?: T;
-};
-declare type DeepConstraint<T> = T extends Record<string, any> ? {
-    [key in keyof T]?: T[key] | DeepConstraint<T[key]>;
-} : Constraint<T>;
-declare type ComparableType = number | Date;
-export declare const gt: <T extends ComparableType>(value: T) => Constraint<T>;
-export declare const ge: <T extends ComparableType>(value: T) => Constraint<T>;
-export declare const gte: <T extends ComparableType>(value: T) => Constraint<T>;
-export declare const lt: <T extends ComparableType>(value: T) => Constraint<T>;
-export declare const lte: <T extends ComparableType>(value: T) => Constraint<T>;
-export declare const le: <T extends ComparableType>(value: T) => Constraint<T>;
-export declare const exists: (column: string) => Constraint<string>;
-export declare const notExists: (column: string) => Constraint<string>;
-export declare const startsWith: (value: string) => Constraint<string>;
-export declare const endsWith: (value: string) => Constraint<string>;
-export declare const pattern: (value: string) => Constraint<string>;
-export declare const is: <T>(value: T) => Constraint<T>;
-export declare const isNot: <T>(value: T) => Constraint<T>;
-export declare const contains: <T>(value: T) => Constraint<T>;
-export declare const includes: (value: string) => Constraint<string>;
-export declare const includesSubstring: (value: string) => Constraint<string>;
-export declare const includesPattern: (value: string) => Constraint<string>;
-export declare const includesAll: (value: string) => Constraint<string>;
-declare type FilterConstraints<T> = {
-    [key in keyof T]?: T[key] extends Record<string, any> ? FilterConstraints<T[key]> : T[key] | DeepConstraint<T[key]>;
-};
-declare type BulkQueryOptions<T> = {
-    filter?: FilterConstraints<T>;
-    sort?: {
-        column: keyof T;
-        direction?: SortDirection;
-    } | keyof T;
-};
-declare type QueryOrConstraint<T, R> = Query<T, R> | Constraint<T>;
-export declare class Query<T, R = T> {
-    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>;
-    constructor(repository: Repository<T> | null, table: string, data: Partial<Query<T, R>>, parent?: Query<T, R>);
-    any(...queries: Query<T, R>[]): Query<T, R>;
-    all(...queries: Query<T, R>[]): Query<T, R>;
-    not(...queries: Query<T, R>[]): Query<T, R>;
-    none(...queries: Query<T, R>[]): Query<T, R>;
-    filter(constraints: FilterConstraints<T>): Query<T, R>;
-    filter<F extends keyof T>(column: F, value: FilterConstraints<T[F]> | DeepConstraint<T[F]>): Query<T, R>;
-    sort<F extends keyof T>(column: F, direction: SortDirection): Query<T, R>;
-    getMany(options?: BulkQueryOptions<T>): Promise<R[]>;
-    getOne(options?: BulkQueryOptions<T>): Promise<R | null>;
-    deleteAll(): Promise<number>;
-    include(columns: Include<T>): this;
-}
-export declare abstract class Repository<T> extends Query<T, Selectable<T>> {
-    select<K extends keyof Selectable<T>>(...columns: K[]): Query<T, Select<T, K>>;
+export declare abstract class Repository<T extends XataRecord> extends Query<T> {
     abstract create(object: Selectable<T>): Promise<T>;
+    abstract createMany(objects: Selectable<T>[]): Promise<T[]>;
     abstract read(id: string): Promise<T | null>;
     abstract update(id: string, object: Partial<T>): Promise<T>;
     abstract delete(id: string): void;
-    abstract query<R>(query: Query<T, R>): Promise<R[]>;
+    abstract query<R extends XataRecord, Options extends QueryOptions<T>>(query: Query<T, R>, options: Options): Promise<Page<T, typeof options['columns'] extends SelectableColumn<T>[] ? Select<T, typeof options['columns'][number]> : R>>;
 }
-export declare class RestRepository<T> extends Repository<T> {
-    client: BaseClient<any>;
-    fetch: any;
+export declare class RestRepository<T extends XataRecord> extends Repository<T> {
+    #private;
     constructor(client: BaseClient<any>, table: string);
-    request(method: string, path: string, body?: unknown): Promise<any>;
-    select<K extends keyof T>(...columns: K[]): Query<T, Select<T, K>>;
+    request<T>(method: string, path: string, body?: unknown): Promise<T | undefined>;
     create(object: T): Promise<T>;
+    createMany(objects: T[]): Promise<T[]>;
     read(id: string): Promise<T | null>;
     update(id: string, object: Partial<T>): Promise<T>;
     delete(id: string): Promise<void>;
-    query<R>(query: Query<T, R>): Promise<R[]>;
+    query<R extends XataRecord, Options extends QueryOptions<T>>(query: Query<T, R>, options: Options): Promise<Page<T, typeof options['columns'] extends SelectableColumn<T>[] ? Select<T, typeof options['columns'][number]> : R>>;
 }
 interface RepositoryFactory {
-    createRepository<T>(client: BaseClient<any>, table: string): Repository<T>;
+    createRepository<T extends XataRecord>(client: BaseClient<any>, table: string): Repository<T>;
 }
 export declare class RestRespositoryFactory implements RepositoryFactory {
-    createRepository<T>(client: BaseClient<any>, table: string): Repository<T>;
+    createRepository<T extends XataRecord>(client: BaseClient<any>, table: string): Repository<T>;
 }
 declare type BranchStrategyValue = string | undefined | null;
 declare type BranchStrategyBuilder = () => BranchStrategyValue | Promise<BranchStrategyValue>;
@@ -115,7 +41,7 @@ declare type BranchStrategy = BranchStrategyValue | BranchStrategyBuilder;
 declare type BranchStrategyOption = NonNullable<BranchStrategy | BranchStrategy[]>;
 export declare type XataClientOptions = {
     fetch?: unknown;
-    databaseURL: string;
+    databaseURL?: string;
     branch: BranchStrategyOption;
     apiKey: string;
     repositoryFactory?: RepositoryFactory;
@@ -134,4 +60,5 @@ export declare class XataError extends Error {
     constructor(message: string, status: number);
 }
 export declare type Links = Record<string, Array<string[]>>;
-export {};
+export * from './api';
+export * from './schema';