@xata.io/client 0.0.0-beta.c9e08d0 → 0.0.0-beta.ca9389a

package/.eslintrc.cjs

@@ -0,0 +1,13 @@
+module.exports = {
+  ignorePatterns: ["dist"],
+  parserOptions: {
+    ecmaVersion: 2020,
+    sourceType: 'module',
+    project: 'client/tsconfig.json'
+  },
+  rules: {
+    '@typescript-eslint/no-explicit-any': 'off',
+    '@typescript-eslint/ban-types': 'off',
+    '@typescript-eslint/no-floating-promises': 'error',
+  }
+};

package/CHANGELOG.md

@@ -0,0 +1,87 @@
+# @xata.io/client
+
+## 0.8.0
+
+### Patch Changes
+
+- bde908e: Refactor client builder
+- ea3eef8: Make records returned by the API readonly
+
+## 0.7.2
+
+### Patch Changes
+
+- 4803b6f: Memoize ApiClient namespaces
+- 1f268d7: Add search in XataClient
+- d58c3d9: Hide private helper utilities
+- f3b731b: Expose branch resolution API
+
+## 0.7.1
+
+### Patch Changes
+
+- 01aef78: Fix bundle for browsers
+- 56be1fd: Allow sending updates with link object
+- fc51771: Add includes operator helper methods
+
+## 0.7.0
+
+### Minor Changes
+
+- 6ce5512: Add bulk operations for all methods
+- 2a1fa4f: Introduced automatic branch resolution mechanism
+
+### Patch Changes
+
+- d033f3a: Improve column selection output type with non-nullable columns
+- b1e92db: Include stack trace with errors
+- deed570: Improve sorting with multiple properties
+- 80b5417: Improve filtering types
+
+## 0.6.0
+
+### Minor Changes
+
+- 084f5df: Add type inference for columns
+- bb73c89: Unify create and insert in a single method overload
+
+### Patch Changes
+
+- 716c487: Forward nullable types on links
+- bb66bb2: Fix error handling with createMany
+- 084f5df: Fix circular dependencies on selectable column
+
+## 0.5.1
+
+### Patch Changes
+
+- 12729ab: Make API client fetch implementation optional
+
+## 0.5.0
+
+### Patch Changes
+
+- 14ec7d1: Fix in Selectable type
+
+## 0.4.0
+
+### Patch Changes
+
+- b951331: Add support for new float column
+- d470610: Add new getAll() method
+- eaf92a8: Expose pagination constants (size and offset limits)
+- 57fde77: Reduce subrequests for createMany
+- eaf92a8: Implement schema-less client
+- 97a3caa: Make createBranch from optional with empty branch
+
+## 0.3.0
+
+### Minor Changes
+
+- 1c0a454: Add API Client and internally use it
+
+### Patch Changes
+
+- 122321c: Fix client in CF workers and Deno
+- a2671b5: Allow cancel or resend workspace invites
+- e73d470: Split insert and create

package/dist/api/client.d.ts

@@ -0,0 +1,95 @@
+import type * as Types from './components';
+import type { FetcherExtraProps, FetchImpl } from './fetcher';
+import { HostProvider } from './providers';
+import type * as Responses from './responses';
+import type * as Schemas from './schemas';
+export interface XataApiClientOptions {
+    fetch?: FetchImpl;
+    apiKey?: string;
+    host?: HostProvider;
+}
+export declare class XataApiClient {
+    #private;
+    constructor(options: XataApiClientOptions);
+    get user(): UserApi;
+    get workspaces(): WorkspaceApi;
+    get databases(): DatabaseApi;
+    get branches(): BranchApi;
+    get tables(): TableApi;
+    get records(): RecordsApi;
+}
+declare class UserApi {
+    private extraProps;
+    constructor(extraProps: FetcherExtraProps);
+    getUser(): Promise<Schemas.UserWithID>;
+    updateUser(user: Schemas.User): Promise<Schemas.UserWithID>;
+    deleteUser(): Promise<void>;
+    getUserAPIKeys(): Promise<Types.GetUserAPIKeysResponse>;
+    createUserAPIKey(keyName: Schemas.APIKeyName): Promise<Types.CreateUserAPIKeyResponse>;
+    deleteUserAPIKey(keyName: Schemas.APIKeyName): Promise<void>;
+}
+declare class WorkspaceApi {
+    private extraProps;
+    constructor(extraProps: FetcherExtraProps);
+    createWorkspace(workspaceMeta: Schemas.WorkspaceMeta): Promise<Schemas.Workspace>;
+    getWorkspacesList(): Promise<Types.GetWorkspacesListResponse>;
+    getWorkspace(workspaceId: Schemas.WorkspaceID): Promise<Schemas.Workspace>;
+    updateWorkspace(workspaceId: Schemas.WorkspaceID, workspaceMeta: Schemas.WorkspaceMeta): Promise<Schemas.Workspace>;
+    deleteWorkspace(workspaceId: Schemas.WorkspaceID): Promise<void>;
+    getWorkspaceMembersList(workspaceId: Schemas.WorkspaceID): Promise<Schemas.WorkspaceMembers>;
+    updateWorkspaceMemberRole(workspaceId: Schemas.WorkspaceID, userId: Schemas.UserID, role: Schemas.Role): Promise<void>;
+    removeWorkspaceMember(workspaceId: Schemas.WorkspaceID, userId: Schemas.UserID): Promise<void>;
+    inviteWorkspaceMember(workspaceId: Schemas.WorkspaceID, email: string, role: Schemas.Role): Promise<Schemas.WorkspaceInvite>;
+    cancelWorkspaceMemberInvite(workspaceId: Schemas.WorkspaceID, inviteId: Schemas.InviteID): Promise<void>;
+    resendWorkspaceMemberInvite(workspaceId: Schemas.WorkspaceID, inviteId: Schemas.InviteID): Promise<void>;
+    acceptWorkspaceMemberInvite(workspaceId: Schemas.WorkspaceID, inviteKey: Schemas.InviteKey): Promise<void>;
+}
+declare class DatabaseApi {
+    private extraProps;
+    constructor(extraProps: FetcherExtraProps);
+    getDatabaseList(workspace: Schemas.WorkspaceID): Promise<Schemas.ListDatabasesResponse>;
+    createDatabase(workspace: Schemas.WorkspaceID, dbName: Schemas.DBName, options?: Types.CreateDatabaseRequestBody): Promise<Types.CreateDatabaseResponse>;
+    deleteDatabase(workspace: Schemas.WorkspaceID, dbName: Schemas.DBName): Promise<void>;
+}
+declare class BranchApi {
+    private extraProps;
+    constructor(extraProps: FetcherExtraProps);
+    getBranchList(workspace: Schemas.WorkspaceID, dbName: Schemas.DBName): Promise<Schemas.ListBranchesResponse>;
+    getBranchDetails(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName): Promise<Schemas.DBBranch>;
+    createBranch(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, from?: string, options?: Types.CreateBranchRequestBody): Promise<void>;
+    deleteBranch(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName): Promise<void>;
+    updateBranchMetadata(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, metadata?: Schemas.BranchMetadata): Promise<void>;
+    getBranchMetadata(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName): Promise<Schemas.BranchMetadata>;
+    getBranchMigrationHistory(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, options?: Types.GetBranchMigrationHistoryRequestBody): Promise<Types.GetBranchMigrationHistoryResponse>;
+    executeBranchMigrationPlan(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, migrationPlan: Types.ExecuteBranchMigrationPlanRequestBody): Promise<void>;
+    getBranchMigrationPlan(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, schema: Schemas.Schema): Promise<Responses.BranchMigrationPlan>;
+    getBranchStats(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName): Promise<Types.GetBranchStatsResponse>;
+}
+declare class TableApi {
+    private extraProps;
+    constructor(extraProps: FetcherExtraProps);
+    createTable(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName): Promise<void>;
+    deleteTable(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName): Promise<void>;
+    updateTable(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, options: Types.UpdateTableRequestBody): Promise<void>;
+    getTableSchema(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName): Promise<Types.GetTableSchemaResponse>;
+    setTableSchema(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, options: Types.SetTableSchemaRequestBody): Promise<void>;
+    getTableColumns(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName): Promise<Types.GetTableColumnsResponse>;
+    addTableColumn(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, column: Schemas.Column): Promise<Responses.MigrationIdResponse>;
+    getColumn(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, columnName: Schemas.ColumnName): Promise<Schemas.Column>;
+    deleteColumn(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, columnName: Schemas.ColumnName): Promise<Responses.MigrationIdResponse>;
+    updateColumn(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, columnName: Schemas.ColumnName, options: Types.UpdateColumnRequestBody): Promise<Responses.MigrationIdResponse>;
+}
+declare class RecordsApi {
+    private extraProps;
+    constructor(extraProps: FetcherExtraProps);
+    insertRecord(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, record: Record<string, any>): Promise<Types.InsertRecordResponse>;
+    insertRecordWithID(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, recordId: Schemas.RecordID, record: Record<string, any>, options?: Types.InsertRecordWithIDQueryParams): Promise<Responses.RecordUpdateResponse>;
+    updateRecordWithID(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, recordId: Schemas.RecordID, record: Record<string, any>, options?: Types.UpdateRecordWithIDQueryParams): Promise<Responses.RecordUpdateResponse>;
+    upsertRecordWithID(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, recordId: Schemas.RecordID, record: Record<string, any>, options?: Types.UpsertRecordWithIDQueryParams): Promise<Responses.RecordUpdateResponse>;
+    deleteRecord(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, recordId: Schemas.RecordID): Promise<void>;
+    getRecord(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, recordId: Schemas.RecordID, options?: Types.GetRecordRequestBody): Promise<Schemas.XataRecord>;
+    bulkInsertTableRecords(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, records: Record<string, any>[]): Promise<Types.BulkInsertTableRecordsResponse>;
+    queryTable(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, query: Types.QueryTableRequestBody): Promise<Responses.QueryResponse>;
+    searchBranch(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, query: Types.SearchBranchRequestBody): Promise<Responses.SearchResponse>;
+}
+export {};

package/dist/api/client.js

@@ -0,0 +1,251 @@
+"use strict";
+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 _XataApiClient_extraProps, _XataApiClient_namespaces;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XataApiClient = void 0;
+const config_1 = require("../util/config");
+const fetch_1 = require("../util/fetch");
+const components_1 = require("./components");
+const providers_1 = require("./providers");
+class XataApiClient {
+    constructor(options) {
+        var _a, _b;
+        _XataApiClient_extraProps.set(this, void 0);
+        _XataApiClient_namespaces.set(this, {});
+        const provider = (_a = options.host) !== null && _a !== void 0 ? _a : 'production';
+        const apiKey = (_b = options === null || options === void 0 ? void 0 : options.apiKey) !== null && _b !== void 0 ? _b : (0, config_1.getAPIKey)();
+        if (!apiKey) {
+            throw new Error('Could not resolve a valid apiKey');
+        }
+        __classPrivateFieldSet(this, _XataApiClient_extraProps, {
+            apiUrl: (0, providers_1.getHostUrl)(provider, 'main'),
+            workspacesApiUrl: (0, providers_1.getHostUrl)(provider, 'workspaces'),
+            fetchImpl: (0, fetch_1.getFetchImplementation)(options.fetch),
+            apiKey
+        }, "f");
+    }
+    get user() {
+        if (!__classPrivateFieldGet(this, _XataApiClient_namespaces, "f").user)
+            __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").user = new UserApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        return __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").user;
+    }
+    get workspaces() {
+        if (!__classPrivateFieldGet(this, _XataApiClient_namespaces, "f").workspaces)
+            __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").workspaces = new WorkspaceApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        return __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").workspaces;
+    }
+    get databases() {
+        if (!__classPrivateFieldGet(this, _XataApiClient_namespaces, "f").databases)
+            __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").databases = new DatabaseApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        return __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").databases;
+    }
+    get branches() {
+        if (!__classPrivateFieldGet(this, _XataApiClient_namespaces, "f").branches)
+            __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").branches = new BranchApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        return __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").branches;
+    }
+    get tables() {
+        if (!__classPrivateFieldGet(this, _XataApiClient_namespaces, "f").tables)
+            __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").tables = new TableApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        return __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").tables;
+    }
+    get records() {
+        if (!__classPrivateFieldGet(this, _XataApiClient_namespaces, "f").records)
+            __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").records = new RecordsApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        return __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").records;
+    }
+}
+exports.XataApiClient = XataApiClient;
+_XataApiClient_extraProps = new WeakMap(), _XataApiClient_namespaces = new WeakMap();
+class UserApi {
+    constructor(extraProps) {
+        this.extraProps = extraProps;
+    }
+    getUser() {
+        return components_1.operationsByTag.users.getUser(Object.assign({}, this.extraProps));
+    }
+    updateUser(user) {
+        return components_1.operationsByTag.users.updateUser(Object.assign({ body: user }, this.extraProps));
+    }
+    deleteUser() {
+        return components_1.operationsByTag.users.deleteUser(Object.assign({}, this.extraProps));
+    }
+    getUserAPIKeys() {
+        return components_1.operationsByTag.users.getUserAPIKeys(Object.assign({}, this.extraProps));
+    }
+    createUserAPIKey(keyName) {
+        return components_1.operationsByTag.users.createUserAPIKey(Object.assign({ pathParams: { keyName } }, this.extraProps));
+    }
+    deleteUserAPIKey(keyName) {
+        return components_1.operationsByTag.users.deleteUserAPIKey(Object.assign({ pathParams: { keyName } }, this.extraProps));
+    }
+}
+class WorkspaceApi {
+    constructor(extraProps) {
+        this.extraProps = extraProps;
+    }
+    createWorkspace(workspaceMeta) {
+        return components_1.operationsByTag.workspaces.createWorkspace(Object.assign({ body: workspaceMeta }, this.extraProps));
+    }
+    getWorkspacesList() {
+        return components_1.operationsByTag.workspaces.getWorkspacesList(Object.assign({}, this.extraProps));
+    }
+    getWorkspace(workspaceId) {
+        return components_1.operationsByTag.workspaces.getWorkspace(Object.assign({ pathParams: { workspaceId } }, this.extraProps));
+    }
+    updateWorkspace(workspaceId, workspaceMeta) {
+        return components_1.operationsByTag.workspaces.updateWorkspace(Object.assign({ pathParams: { workspaceId }, body: workspaceMeta }, this.extraProps));
+    }
+    deleteWorkspace(workspaceId) {
+        return components_1.operationsByTag.workspaces.deleteWorkspace(Object.assign({ pathParams: { workspaceId } }, this.extraProps));
+    }
+    getWorkspaceMembersList(workspaceId) {
+        return components_1.operationsByTag.workspaces.getWorkspaceMembersList(Object.assign({ pathParams: { workspaceId } }, this.extraProps));
+    }
+    updateWorkspaceMemberRole(workspaceId, userId, role) {
+        return components_1.operationsByTag.workspaces.updateWorkspaceMemberRole(Object.assign({ pathParams: { workspaceId, userId }, body: { role } }, this.extraProps));
+    }
+    removeWorkspaceMember(workspaceId, userId) {
+        return components_1.operationsByTag.workspaces.removeWorkspaceMember(Object.assign({ pathParams: { workspaceId, userId } }, this.extraProps));
+    }
+    inviteWorkspaceMember(workspaceId, email, role) {
+        return components_1.operationsByTag.workspaces.inviteWorkspaceMember(Object.assign({ pathParams: { workspaceId }, body: { email, role } }, this.extraProps));
+    }
+    cancelWorkspaceMemberInvite(workspaceId, inviteId) {
+        return components_1.operationsByTag.workspaces.cancelWorkspaceMemberInvite(Object.assign({ pathParams: { workspaceId, inviteId } }, this.extraProps));
+    }
+    resendWorkspaceMemberInvite(workspaceId, inviteId) {
+        return components_1.operationsByTag.workspaces.resendWorkspaceMemberInvite(Object.assign({ pathParams: { workspaceId, inviteId } }, this.extraProps));
+    }
+    acceptWorkspaceMemberInvite(workspaceId, inviteKey) {
+        return components_1.operationsByTag.workspaces.acceptWorkspaceMemberInvite(Object.assign({ pathParams: { workspaceId, inviteKey } }, this.extraProps));
+    }
+}
+class DatabaseApi {
+    constructor(extraProps) {
+        this.extraProps = extraProps;
+    }
+    getDatabaseList(workspace) {
+        return components_1.operationsByTag.database.getDatabaseList(Object.assign({ pathParams: { workspace } }, this.extraProps));
+    }
+    createDatabase(workspace, dbName, options = {}) {
+        return components_1.operationsByTag.database.createDatabase(Object.assign({ pathParams: { workspace, dbName }, body: options }, this.extraProps));
+    }
+    deleteDatabase(workspace, dbName) {
+        return components_1.operationsByTag.database.deleteDatabase(Object.assign({ pathParams: { workspace, dbName } }, this.extraProps));
+    }
+}
+class BranchApi {
+    constructor(extraProps) {
+        this.extraProps = extraProps;
+    }
+    getBranchList(workspace, dbName) {
+        return components_1.operationsByTag.branch.getBranchList(Object.assign({ pathParams: { workspace, dbName } }, this.extraProps));
+    }
+    getBranchDetails(workspace, database, branch) {
+        return components_1.operationsByTag.branch.getBranchDetails(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` } }, this.extraProps));
+    }
+    createBranch(workspace, database, branch, from = '', options = {}) {
+        return components_1.operationsByTag.branch.createBranch(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` }, queryParams: { from }, body: options }, this.extraProps));
+    }
+    deleteBranch(workspace, database, branch) {
+        return components_1.operationsByTag.branch.deleteBranch(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` } }, this.extraProps));
+    }
+    updateBranchMetadata(workspace, database, branch, metadata = {}) {
+        return components_1.operationsByTag.branch.updateBranchMetadata(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` }, body: metadata }, this.extraProps));
+    }
+    getBranchMetadata(workspace, database, branch) {
+        return components_1.operationsByTag.branch.getBranchMetadata(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` } }, this.extraProps));
+    }
+    getBranchMigrationHistory(workspace, database, branch, options = {}) {
+        return components_1.operationsByTag.branch.getBranchMigrationHistory(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` }, body: options }, this.extraProps));
+    }
+    executeBranchMigrationPlan(workspace, database, branch, migrationPlan) {
+        return components_1.operationsByTag.branch.executeBranchMigrationPlan(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` }, body: migrationPlan }, this.extraProps));
+    }
+    getBranchMigrationPlan(workspace, database, branch, schema) {
+        return components_1.operationsByTag.branch.getBranchMigrationPlan(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` }, body: schema }, this.extraProps));
+    }
+    getBranchStats(workspace, database, branch) {
+        return components_1.operationsByTag.branch.getBranchStats(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` } }, this.extraProps));
+    }
+}
+class TableApi {
+    constructor(extraProps) {
+        this.extraProps = extraProps;
+    }
+    createTable(workspace, database, branch, tableName) {
+        return components_1.operationsByTag.table.createTable(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName } }, this.extraProps));
+    }
+    deleteTable(workspace, database, branch, tableName) {
+        return components_1.operationsByTag.table.deleteTable(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName } }, this.extraProps));
+    }
+    updateTable(workspace, database, branch, tableName, options) {
+        return components_1.operationsByTag.table.updateTable(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName }, body: options }, this.extraProps));
+    }
+    getTableSchema(workspace, database, branch, tableName) {
+        return components_1.operationsByTag.table.getTableSchema(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName } }, this.extraProps));
+    }
+    setTableSchema(workspace, database, branch, tableName, options) {
+        return components_1.operationsByTag.table.setTableSchema(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName }, body: options }, this.extraProps));
+    }
+    getTableColumns(workspace, database, branch, tableName) {
+        return components_1.operationsByTag.table.getTableColumns(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName } }, this.extraProps));
+    }
+    addTableColumn(workspace, database, branch, tableName, column) {
+        return components_1.operationsByTag.table.addTableColumn(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName }, body: column }, this.extraProps));
+    }
+    getColumn(workspace, database, branch, tableName, columnName) {
+        return components_1.operationsByTag.table.getColumn(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, columnName } }, this.extraProps));
+    }
+    deleteColumn(workspace, database, branch, tableName, columnName) {
+        return components_1.operationsByTag.table.deleteColumn(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, columnName } }, this.extraProps));
+    }
+    updateColumn(workspace, database, branch, tableName, columnName, options) {
+        return components_1.operationsByTag.table.updateColumn(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, columnName }, body: options }, this.extraProps));
+    }
+}
+class RecordsApi {
+    constructor(extraProps) {
+        this.extraProps = extraProps;
+    }
+    insertRecord(workspace, database, branch, tableName, record) {
+        return components_1.operationsByTag.records.insertRecord(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName }, body: record }, this.extraProps));
+    }
+    insertRecordWithID(workspace, database, branch, tableName, recordId, record, options = {}) {
+        return components_1.operationsByTag.records.insertRecordWithID(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId }, queryParams: options, body: record }, this.extraProps));
+    }
+    updateRecordWithID(workspace, database, branch, tableName, recordId, record, options = {}) {
+        return components_1.operationsByTag.records.updateRecordWithID(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId }, queryParams: options, body: record }, this.extraProps));
+    }
+    upsertRecordWithID(workspace, database, branch, tableName, recordId, record, options = {}) {
+        return components_1.operationsByTag.records.upsertRecordWithID(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId }, queryParams: options, body: record }, this.extraProps));
+    }
+    deleteRecord(workspace, database, branch, tableName, recordId) {
+        return components_1.operationsByTag.records.deleteRecord(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId } }, this.extraProps));
+    }
+    getRecord(workspace, database, branch, tableName, recordId, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    options = {}) {
+        return components_1.operationsByTag.records.getRecord(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId } }, this.extraProps));
+    }
+    bulkInsertTableRecords(workspace, database, branch, tableName, records) {
+        return components_1.operationsByTag.records.bulkInsertTableRecords(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName }, body: { records } }, this.extraProps));
+    }
+    queryTable(workspace, database, branch, tableName, query) {
+        return components_1.operationsByTag.records.queryTable(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName }, body: query }, this.extraProps));
+    }
+    searchBranch(workspace, database, branch, query) {
+        return components_1.operationsByTag.records.searchBranch(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` }, body: query }, this.extraProps));
+    }
+}