@xata.io/client 0.0.0-alpha.vfb85b8b → 0.0.0-alpha.vfbac5b5

package/package.json

@@ -1,16 +1,24 @@
 {
   "name": "@xata.io/client",
-  "version": "0.0.0-alpha.vfb85b8b",
+  "version": "0.0.0-alpha.vfbac5b5",
   "description": "Xata.io SDK for TypeScript and JavaScript",
-  "main": "./dist/index.js",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
+  "exports": {
+    "import": "./dist/index.mjs",
+    "require": "./dist/index.cjs"
+  },
   "browser": {
     "child_process": false
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "tsc -p tsconfig.build.json",
-    "prepack": "npm run build"
+    "build": "rimraf dist && rollup -c",
+    "prepack": "npm run build",
+    "prebuild": "node ../../scripts/add-version-file.mjs"
+  },
+  "peerDependencies": {
+    "typescript": ">=4.5"
   },
   "repository": {
     "type": "git",
@@ -23,5 +31,5 @@
     "url": "https://github.com/xataio/client-ts/issues"
   },
   "homepage": "https://github.com/xataio/client-ts/blob/main/client/README.md",
-  "gitHead": "fb85b8b847299a3fa60b6f347255484ffdc1752c"
+  "gitHead": "fbac5b59b88793a2d018d6a0ef8d8220db6969f9"
 }

package/rollup.config.js

@@ -0,0 +1,29 @@
+import dts from 'rollup-plugin-dts';
+import esbuild from 'rollup-plugin-esbuild';
+
+export default [
+  {
+    input: 'src/index.ts',
+    plugins: [esbuild()],
+    output: [
+      {
+        file: `dist/index.cjs`,
+        format: 'cjs',
+        sourcemap: true
+      },
+      {
+        file: `dist/index.mjs`,
+        format: 'es',
+        sourcemap: true
+      }
+    ]
+  },
+  {
+    input: 'src/index.ts',
+    plugins: [dts()],
+    output: {
+      file: `dist/index.d.ts`,
+      format: 'es'
+    }
+  }
+];

package/tsconfig.json

@@ -1,15 +1,16 @@
 {
   "compilerOptions": {
-    "target": "ES6",
-    "lib": ["dom", "esnext"],
+    "target": "es2020",
+    "lib": ["esnext"],
     "allowJs": true,
     "skipLibCheck": true,
     "esModuleInterop": true,
     "allowSyntheticDefaultImports": true,
     "strict": true,
+    "strictNullChecks": true,
     "forceConsistentCasingInFileNames": true,
     "noFallthroughCasesInSwitch": true,
-    "module": "CommonJS",
+    "module": "es2020",
     "moduleResolution": "node",
     "resolveJsonModule": true,
     "isolatedModules": true,
@@ -17,5 +18,6 @@
     "outDir": "dist",
     "declaration": true
   },
-  "include": ["src"]
+  "include": ["src"],
+  "exclude": ["node_modules"]
 }

package/dist/api/client.d.ts

@@ -1,95 +0,0 @@
-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

@@ -1,251 +0,0 @@
-"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));
-    }
-}