@xata.io/client 0.2.2 → 0.3.0

package/dist/api/components.js

@@ -0,0 +1,1001 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchBranch = exports.queryTable = exports.bulkInsertTableRecords = exports.getRecord = exports.deleteRecord = exports.upsertRecordWithID = exports.updateRecordWithID = exports.insertRecordWithID = exports.insertRecord = exports.updateColumn = exports.deleteColumn = exports.getColumn = exports.addTableColumn = exports.getTableColumns = exports.setTableSchema = exports.getTableSchema = exports.updateTable = exports.deleteTable = exports.createTable = exports.getBranchStats = exports.getBranchMigrationPlan = exports.executeBranchMigrationPlan = exports.getBranchMigrationHistory = exports.getBranchMetadata = exports.updateBranchMetadata = exports.deleteBranch = exports.createBranch = exports.getBranchDetails = exports.deleteDatabase = exports.createDatabase = exports.getBranchList = exports.getDatabaseList = exports.acceptWorkspaceMemberInvite = exports.resendWorkspaceMemberInvite = exports.cancelWorkspaceMemberInvite = exports.inviteWorkspaceMember = exports.removeWorkspaceMember = exports.updateWorkspaceMemberRole = exports.getWorkspaceMembersList = exports.deleteWorkspace = exports.updateWorkspace = exports.getWorkspace = exports.getWorkspacesList = exports.createWorkspace = exports.deleteUserAPIKey = exports.createUserAPIKey = exports.getUserAPIKeys = exports.deleteUser = exports.updateUser = exports.getUser = void 0;
+exports.operationsByTag = void 0;
+/**
+ * Generated by @openapi-codegen
+ *
+ * @version 1.0
+ */
+const fetcher_1 = require("./fetcher");
+/**
+ * Return details of the user making the request
+ */
+const getUser = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/user', method: 'get' }, variables));
+exports.getUser = getUser;
+/**
+ * Update user info
+ */
+const updateUser = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/user', method: 'put' }, variables));
+exports.updateUser = updateUser;
+/**
+ * Delete the user making the request
+ */
+const deleteUser = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/user', method: 'delete' }, variables));
+exports.deleteUser = deleteUser;
+/**
+ * Retrieve a list of existing user API keys
+ */
+const getUserAPIKeys = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/user/keys', method: 'get' }, variables));
+exports.getUserAPIKeys = getUserAPIKeys;
+/**
+ * Create and return new API key
+ */
+const createUserAPIKey = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/user/keys/{keyName}', method: 'post' }, variables));
+exports.createUserAPIKey = createUserAPIKey;
+/**
+ * Delete an existing API key
+ */
+const deleteUserAPIKey = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/user/keys/{keyName}', method: 'delete' }, variables));
+exports.deleteUserAPIKey = deleteUserAPIKey;
+/**
+ * Creates a new workspace with the user requesting it as its single owner.
+ */
+const createWorkspace = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/workspaces', method: 'post' }, variables));
+exports.createWorkspace = createWorkspace;
+/**
+ * Retrieve the list of workspaces the user belongs to
+ */
+const getWorkspacesList = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/workspaces', method: 'get' }, variables));
+exports.getWorkspacesList = getWorkspacesList;
+/**
+ * Retrieve workspace info from a workspace ID
+ */
+const getWorkspace = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/workspaces/{workspaceId}', method: 'get' }, variables));
+exports.getWorkspace = getWorkspace;
+/**
+ * Update workspace info
+ */
+const updateWorkspace = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/workspaces/{workspaceId}', method: 'put' }, variables));
+exports.updateWorkspace = updateWorkspace;
+/**
+ * Delete the workspace with the provided ID
+ */
+const deleteWorkspace = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/workspaces/{workspaceId}', method: 'delete' }, variables));
+exports.deleteWorkspace = deleteWorkspace;
+/**
+ * Retrieve the list of members of the given workspace
+ */
+const getWorkspaceMembersList = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/workspaces/{workspaceId}/members', method: 'get' }, variables));
+exports.getWorkspaceMembersList = getWorkspaceMembersList;
+/**
+ * Update a workspace member role. Workspaces must always have at least one owner, so this operation will fail if trying to remove owner role from the last owner in the workspace.
+ */
+const updateWorkspaceMemberRole = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/workspaces/{workspaceId}/members/{userId}', method: 'put' }, variables));
+exports.updateWorkspaceMemberRole = updateWorkspaceMemberRole;
+/**
+ * Remove the member from the workspace
+ */
+const removeWorkspaceMember = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/workspaces/{workspaceId}/members/{userId}', method: 'delete' }, variables));
+exports.removeWorkspaceMember = removeWorkspaceMember;
+/**
+ * Invite some user to join the workspace with the given role
+ */
+const inviteWorkspaceMember = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/workspaces/{workspaceId}/invites', method: 'post' }, variables));
+exports.inviteWorkspaceMember = inviteWorkspaceMember;
+/**
+ * This operation provides a way to cancel invites by deleting them. Already accepted invites cannot be deleted.
+ */
+const cancelWorkspaceMemberInvite = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/workspaces/{workspaceId}/invites/{inviteId}', method: 'delete' }, variables));
+exports.cancelWorkspaceMemberInvite = cancelWorkspaceMemberInvite;
+/**
+ * This operation provides a way to resend an Invite notification. Invite notifications can only be sent for Invites not yet accepted.
+ */
+const resendWorkspaceMemberInvite = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/workspaces/{workspaceId}/invites/{inviteId}/resend', method: 'post' }, variables));
+exports.resendWorkspaceMemberInvite = resendWorkspaceMemberInvite;
+/**
+ * Accept the invitation to join a workspace. If the operation succeeds the user will be a member of the workspace
+ */
+const acceptWorkspaceMemberInvite = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/workspaces/{workspaceId}/invites/{inviteKey}/accept', method: 'post' }, variables));
+exports.acceptWorkspaceMemberInvite = acceptWorkspaceMemberInvite;
+/**
+ * List all databases available in your Workspace.
+ */
+const getDatabaseList = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/dbs', method: 'get' }, variables));
+exports.getDatabaseList = getDatabaseList;
+/**
+ * List all available Branches
+ */
+const getBranchList = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/dbs/{dbName}', method: 'get' }, variables));
+exports.getBranchList = getBranchList;
+/**
+ * Create Database with identifier name
+ */
+const createDatabase = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/dbs/{dbName}', method: 'put' }, variables));
+exports.createDatabase = createDatabase;
+/**
+ * Delete a database and all of its branches and tables permanently.
+ */
+const deleteDatabase = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/dbs/{dbName}', method: 'delete' }, variables));
+exports.deleteDatabase = deleteDatabase;
+const getBranchDetails = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}', method: 'get' }, variables));
+exports.getBranchDetails = getBranchDetails;
+const createBranch = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}', method: 'put' }, variables));
+exports.createBranch = createBranch;
+/**
+ * Delete the branch in the database and all its resources
+ */
+const deleteBranch = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}', method: 'delete' }, variables));
+exports.deleteBranch = deleteBranch;
+/**
+ * Update the branch metadata
+ */
+const updateBranchMetadata = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/metadata', method: 'put' }, variables));
+exports.updateBranchMetadata = updateBranchMetadata;
+const getBranchMetadata = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/metadata', method: 'get' }, variables));
+exports.getBranchMetadata = getBranchMetadata;
+const getBranchMigrationHistory = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/migrations', method: 'get' }, variables));
+exports.getBranchMigrationHistory = getBranchMigrationHistory;
+/**
+ * Apply a migration plan to the branch
+ */
+const executeBranchMigrationPlan = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/migrations/execute', method: 'post' }, variables));
+exports.executeBranchMigrationPlan = executeBranchMigrationPlan;
+/**
+ * Compute a migration plan from a target schema the branch should be migrated too.
+ */
+const getBranchMigrationPlan = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/migrations/plan', method: 'post' }, variables));
+exports.getBranchMigrationPlan = getBranchMigrationPlan;
+/**
+ * Get branch usage metrics.
+ */
+const getBranchStats = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/stats', method: 'get' }, variables));
+exports.getBranchStats = getBranchStats;
+/**
+ * Creates a new table with the given name. Returns 422 if a table with the same name already exists.
+ */
+const createTable = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/tables/{tableName}', method: 'put' }, variables));
+exports.createTable = createTable;
+/**
+ * Deletes the table with the given name.
+ */
+const deleteTable = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/tables/{tableName}', method: 'delete' }, variables));
+exports.deleteTable = deleteTable;
+/**
+ * Update table. Currently there is only one update operation supported: renaming the table by providing a new name.
+ *
+ * In the example below, we rename a table from “users” to “people”:
+ *
+ * ```jsx
+ * PATCH /db/test:main/tables/users
+ * {
+ *   "name": "people"
+ * }
+ * ```
+ */
+const updateTable = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/tables/{tableName}', method: 'patch' }, variables));
+exports.updateTable = updateTable;
+const getTableSchema = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/tables/{tableName}/schema', method: 'get' }, variables));
+exports.getTableSchema = getTableSchema;
+const setTableSchema = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/tables/{tableName}/schema', method: 'put' }, variables));
+exports.setTableSchema = setTableSchema;
+/**
+ * Retrieves the list of table columns and their definition. This endpoint returns the column list with object columns being reported with their
+ * full dot-separated path (flattened).
+ */
+const getTableColumns = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/tables/{tableName}/columns', method: 'get' }, variables));
+exports.getTableColumns = getTableColumns;
+/**
+ * Adds a new column to the table. The body of the request should contain the column definition. In the column definition, the 'name' field should
+ * contain the full path separated by dots. If the parent objects do not exists, they will be automatically created. For example,
+ * passing `"name": "address.city"` will auto-create the `address` object if it doesn't exist.
+ */
+const addTableColumn = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/tables/{tableName}/columns', method: 'post' }, variables));
+exports.addTableColumn = addTableColumn;
+/**
+ * Get the definition of a single column. To refer to sub-objects, the column name can contain dots. For example `address.country`.
+ */
+const getColumn = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/tables/{tableName}/columns/{columnName}', method: 'get' }, variables));
+exports.getColumn = getColumn;
+/**
+ * Deletes the specified column. To refer to sub-objects, the column name can contain dots. For example `address.country`.
+ */
+const deleteColumn = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/tables/{tableName}/columns/{columnName}', method: 'delete' }, variables));
+exports.deleteColumn = deleteColumn;
+/**
+ * Update column with partial data. Can be used for renaming the column by providing a new "name" field. To refer to sub-objects, the column name can contain dots. For example `address.country`.
+ */
+const updateColumn = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/tables/{tableName}/columns/{columnName}', method: 'patch' }, variables));
+exports.updateColumn = updateColumn;
+/**
+ * Insert a new Record into the Table
+ */
+const insertRecord = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/tables/{tableName}/data', method: 'post' }, variables));
+exports.insertRecord = insertRecord;
+/**
+ * By default, IDs are auto-generated when data is insterted into Xata. Sending a request to this endpoint allows us to insert a record with a pre-existing ID, bypassing the default automatic ID generation.
+ */
+const insertRecordWithID = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/tables/{tableName}/data/{recordId}', method: 'put' }, variables));
+exports.insertRecordWithID = insertRecordWithID;
+const updateRecordWithID = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/tables/{tableName}/data/{recordId}', method: 'patch' }, variables));
+exports.updateRecordWithID = updateRecordWithID;
+const upsertRecordWithID = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/tables/{tableName}/data/{recordId}', method: 'post' }, variables));
+exports.upsertRecordWithID = upsertRecordWithID;
+const deleteRecord = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/tables/{tableName}/data/{recordId}', method: 'delete' }, variables));
+exports.deleteRecord = deleteRecord;
+/**
+ * Retrieve record by ID
+ */
+const getRecord = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/tables/{tableName}/data/{recordId}', method: 'get' }, variables));
+exports.getRecord = getRecord;
+/**
+ * Bulk insert records
+ */
+const bulkInsertTableRecords = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/tables/{tableName}/bulk', method: 'post' }, variables));
+exports.bulkInsertTableRecords = bulkInsertTableRecords;
+/**
+ * The Query Table API can be used to retrieve all records in a table.
+ * The API support filtering, sorting, selecting a subset of columns, and pagination.
+ *
+ * The overall structure of the request looks like this:
+ *
+ * ```json
+ * // POST /db/<dbname>:<branch>/tables/<table>/query
+ * {
+ *   "columns": [...],
+ *   "filter": {
+ *     "$all": [...]
+ *     "$any": [...]
+ *     ...
+ *   },
+ *   "sort": {
+ *     "multiple": [...]
+ *     ...
+ *   },
+ *   "page": {
+ *     ...
+ *   }
+ * }
+ * ```
+ *
+ * ### Column selection
+ *
+ * If the `columns` array is not specified, all columns are included. For link
+ * fields, only the ID column of the linked records is included in the response.
+ *
+ * If the `columns` array is specified, only the selected columns are included.
+ * The `*` wildcard can be used to select all columns of the given array
+ *
+ * For objects and link fields, if the column name of the object is specified, we
+ * include all of its sub-keys. If only some sub-keys are specified (via dotted
+ * notation, e.g. `"settings.plan"` ), then only those sub-keys from the object
+ * are included.
+ *
+ * By the way of example, assuming two tables like this:
+ *
+ * ```json {"truncate": true}
+ * {
+ *   "formatVersion": "1.0",
+ *   "tables": [
+ *     {
+ *       "name": "teams",
+ *       "columns": [
+ *         {
+ *           "name": "name",
+ *           "type": "string"
+ *         },
+ *         {
+ *           "name": "owner",
+ *           "type": "link",
+ *           "link": {
+ *             "table": "users"
+ *           }
+ *         }
+ *       ]
+ *     },
+ *     {
+ *       "name": "users",
+ *       "columns": [
+ *         {
+ *           "name": "email",
+ *           "type": "email"
+ *         },
+ *         {
+ *           "name": "full_name",
+ *           "type": "string"
+ *         },
+ *         {
+ *           "name": "address",
+ *           "type": "object",
+ *           "columns": [
+ *             {
+ *               "name": "street",
+ *               "type": "string"
+ *             },
+ *             {
+ *               "name": "number",
+ *               "type": "int"
+ *             },
+ *             {
+ *               "name": "zipcode",
+ *               "type": "int"
+ *             }
+ *           ]
+ *         },
+ *         {
+ *           "name": "team",
+ *           "type": "link",
+ *           "link": {
+ *             "table": "teams"
+ *           }
+ *         }
+ *       ]
+ *     }
+ *   ]
+ * }
+ * ```
+ *
+ * A query like this:
+ *
+ * ```json
+ * POST /db/<dbname>:<branch>/tables/<table>/query
+ * {
+ *   "columns": [
+ *     "name",
+ *     "address.*"
+ *   ]
+ * }
+ * ```
+ *
+ * returns objects like:
+ *
+ * ```json
+ * {
+ *   "name": "Kilian",
+ *   "address": {
+ *     "street": "New street",
+ *     "number": 41,
+ *     "zipcode": 10407
+ *   }
+ * }
+ * ```
+ *
+ * while a query like this:
+ *
+ * ```json
+ * POST /db/<dbname>:<branch>/tables/<table>/query
+ * {
+ *   "columns": [
+ *     "name",
+ *     "address.street"
+ *   ]
+ * }
+ * ```
+ *
+ * returns objects like:
+ *
+ * ```json
+ * {
+ *   "name": "Kilian",
+ *   "address": {
+ *     "street": "New street",
+ *   }
+ * }
+ * ```
+ *
+ * If you want to return all columns from the main table and selected columns from the linked table, you can do it like this:
+ *
+ * ```json
+ * {
+ *   "columns": [
+ *     "*",
+ *     "team.name"
+ *   ]
+ * }
+ * ```
+ *
+ * The `"*"` in the above means all columns, including columns of objects. This returns data like:
+ *
+ * ```json
+ * {
+ *   "name": "Kilian",
+ *   "email": "kilian@gmail.com",
+ *   "address": {
+ *     "street": "New street",
+ *     "number": 41,
+ *     "zipcode": 10407
+ *   },
+ *   "team": {
+ *     "id": "XX",
+ *     "xata": {
+ *       "version": 0,
+ *     },
+ *     "name": "first team"
+ *   }
+ * }
+ * ```
+ *
+ * If you want all columns of the linked table, you can do:
+ *
+ * ```json
+ * {
+ *   "columns": [
+ *     "*",
+ *     "team.*"
+ *   ]
+ * }
+ * ```
+ *
+ * This returns, for example:
+ *
+ * ```json
+ * {
+ *   "name": "Kilian",
+ *   "email": "kilian@gmail.com",
+ *   "address": {
+ *     "street": "New street",
+ *     "number": 41,
+ *     "zipcode": 10407
+ *   },
+ *   "team": {
+ *     "id": "XX",
+ *     "xata": {
+ *       "version": 0,
+ *     },
+ *     "name": "first team",
+ *     "code": "A1"
+ *   }
+ * }
+ * ```
+ *
+ * ### Filtering
+ *
+ * There are two types of operators:
+ *
+ * - Operators that work on a single column: `$is`, `$contains`, `$pattern`,
+ *   `$includes`, `$gt`, etc.
+ * - Control operators that combine multiple conditions: `$any`, `$all`, `$not` ,
+ *   `$none`, etc.
+ *
+ * All operators start with an `$` to differentiate them from column names
+ * (which are not allowed to start with an underscore).
+ *
+ * #### Exact matching and control operators
+ *
+ * Filter by one column:
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "<column_name>": "value"
+ *   }
+ * }
+ * ```
+ *
+ * This is equivalent to using the `$is` operator:
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "<column_name>": {
+ *       "$is": "value"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * For example:
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *       "name": "r2",
+ *   }
+ * }
+ * ```
+ *
+ * Or:
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "name": {
+ *       "$is": "r2"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * For objects, both dots and nested versions work:
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *       "settings.plan": "free",
+ *   }
+ * }
+ * ```
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "settings": {
+ *       "plan": "free"
+ *     },
+ *   },
+ * }
+ * ```
+ *
+ * If you want to OR together multiple values, you can use an array of values:
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "settings.plan": ["free", "paid"]
+ *   },
+ * }
+ * ```
+ *
+ * Same query with `$is` operator:
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "settings.plan": { "$is": ["free", "paid"]}
+ *   },
+ * }
+ * ```
+ *
+ * Specifying multiple columns, ANDs them together:
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *       "settings.dark": true,
+ *       "settings.plan": "free",
+ *   },
+ * }
+ * ```
+ *
+ * To be more explicit about it, you can use `$all` or `$any`:
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *       "$any": {
+ *         "settings.dark": true,
+ *         "settings.plan": "free",
+ *       }
+ *   },
+ * }
+ * ```
+ *
+ * `$all` and `$any` can also receive an array of objects, which allows for repeating columns:
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "$any": [
+ *       {
+ *         "name": "r1",
+ *       },
+ *       {
+ *         "name": "r2",
+ *       },
+ *     ],
+ * }
+ * ```
+ *
+ * You can check for a value being not-null with `$exists`:
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "$exists": "settings",
+ *   },
+ * }
+ * ```
+ *
+ * This can be combined with `$all` or `$any` :
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "$all": [
+ *       {
+ *         "$exists": "settings",
+ *       },
+ *       {
+ *         "$exists": "name",
+ *       },
+ *     ],
+ *   }
+ * }
+ * ```
+ *
+ * We can also make the negation version, `$notExists` :
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "$notExists": "settings",
+ *   },
+ * }
+ * ```
+ *
+ * #### Partial match
+ *
+ * `$contains` is the simplest operator for partial matching. We should generally
+ * discourage overusing `$contains` because it typically can't make use of
+ * indices.
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "<column_name>": {
+ *       "$contains": "value"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * Wildcards are supported via the `$pattern` operator:
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "<column_name>": {
+ *         "$pattern": "v*alue*"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * We could also have `$endsWith` and `$startsWith` operators:
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "<column_name>": {
+ *         "$endsWith": ".gz"
+ *     },
+ *     "<column_name>": {
+ *         "$startsWith": "tmp-"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * #### Numeric/date ranges
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *       "<column_name>": {
+ *         "$ge": 0,
+ *         "$lt": 100
+ *       }
+ *   }
+ * }
+ * ```
+ *
+ * The supported operators are `$gt`, `$lt`, `$ge`, `$le`.
+ *
+ * Date ranges would support the same operators, with the date as string in RFC 3339:
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *       "<column_name>": {
+ *         "$gt": "2019-10-12T07:20:50.52Z",
+ *         "$lt": "2021-10-12T07:20:50.52Z"
+ *       }
+ *   }
+ * }
+ * ```
+ *
+ * #### Negations
+ *
+ * A general `$not` operator can inverse any operation.
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "$not": {
+ *       "<column_name1>": "value1",
+ *       "<column_name2>": "value1"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * Note: in the above the two condition are AND together, so this does (NOT ( ...
+ * AND ...))
+ *
+ * Or more complex:
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "$not": {
+ *       "$any": [{
+ *         "<column_name1>": "value1"
+ *       }, {
+ *         "$all": [{
+ *           "<column_name2>": "value2"
+ *         }, {
+ *           "<column_name3>": "value3"
+ *         }]
+ *       }]
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The `$not: { $any: {}}` can be shorted using the `$none` operator:
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "$none": {
+ *       "<column_name1>": "value1",
+ *       "<column_name2>": "value1"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * In addition, we can add specific operators like `$isNot` to simplify expressions:
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "<column_name>": {
+ *       "$isNot": "2019-10-12T07:20:50.52Z"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * #### Working with arrays
+ *
+ * To test that an array contains a value, use `$includes`.
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "<array_name>": {
+ *       "$includes": "value"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The `$includes` operator accepts a custom predicate that will check if any
+ * array values matches the predicate. For example a complex predicate can include
+ * the `$all` , `$contains` and `$endsWith` operators:
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "<array name>": {
+ *       "$includes": {
+ *         "$all": [
+ *           {"$contains": "label"},
+ *           {"$not": {"$endsWith": "-debug"}}
+ *         ]
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The `$includes` all operator succeeds if any column in the array matches the
+ * predicate. The `$includesAll` operator succeeds if all array items match the
+ * predicate. The `$includesNone` operator succeeds if no array item matches the
+ * predicate. The `$includes` operator is a synonym for the `$includesAny`
+ * operator.
+ *
+ * ### Sorting
+ *
+ * Sorting by one element:
+ *
+ * ```json
+ * POST /db/demo:main/tables/table/query
+ * {
+ *   "sort": {
+ *     "index": "asc"
+ *   }
+ * }
+ * ```
+ *
+ * or descendently:
+ *
+ * ```json
+ * POST /db/demo:main/tables/table/query
+ * {
+ *   "sort": {
+ *     "index": "desc"
+ *   }
+ * }
+ * ```
+ *
+ * Sorting by multiple fields:
+ *
+ * ```json
+ * POST /db/demo:main/tables/table/query
+ * {
+ *   "sort": [
+ *     {
+ *       "index": "desc"
+ *     },
+ *     {
+ *       "createdAt": "desc"
+ *     }
+ *   ]
+ * }
+ * ```
+ *
+ *
+ * ### Pagination
+ *
+ * We offer cursor pagination and offset pagination. The offset pagination is limited
+ * in the amount of data it can retrieve, so we recommend the cursor pagination if you have more than 1000 records.
+ *
+ * Example of size + offset pagination:
+ *
+ * ```json
+ * POST /db/demo:main/tables/table/query
+ * {
+ *   "page": {
+ *     "size": 100,
+ *     "offset": 200
+ *   }
+ * }
+ * ```
+ *
+ * The `page.size` parameter represents the maximum number of records returned by this query. It has a default value of 20 and a maximum value of 200.
+ * The `page.offset` parameter represents the number of matching records to skip. It has a default value of 0 and a maximum value of 800.
+ *
+ * Example of cursor pagination:
+ *
+ * ```json
+ * POST /db/demo:main/tables/table/query
+ * {
+ *   "page": {
+ *     "after":"fMoxCsIwFIDh3WP8c4amDai5hO5SJCRNfaVSeC9b6d1FD"
+ *   }
+ * }
+ * ```
+ *
+ * In the above example, the value of the `page.after` parameter is the cursor returned by the previous query. A sample response is shown below:
+ *
+ * ```json
+ * {
+ *   "meta": {
+ *     "page": {
+ *       "cursor": "fMoxCsIwFIDh3WP8c4amDai5hO5SJCRNfaVSeC9b6d1FD",
+ *       "more": true
+ *     }
+ *   },
+ *   "records": [...]
+ * }
+ * ```
+ *
+ * The `page` object might contain the follow keys, in addition to `size` and `offset` that were introduced before:
+ *
+ * - `after`: Return the next page 'after' the current cursor
+ * - `before`: Return the previous page 'before' the current cursor.
+ * - `first`: Return the first page in the table from a cursor.
+ * - `last`: Return the last N records in the table from a cursor, where N is the `page.size` parameter.
+ *
+ * The request will fail if an invalid cursor value is given to `page.before`,
+ * `page.after`, `page.first` , or `page.last`. No other cursor setting can be
+ * used if `page.first` or `page.last` is set in a query.
+ *
+ * If both `page.before` and `page.after` parameters are present we treat the
+ * request as a range query. The range query will return all entries after
+ * `page.after`, but before `page.before`, up to `page.size` or the maximum
+ * page size. This query requires both cursors to use the same filters and sort
+ * settings, plus we require `page.after < page.before`. The range query returns
+ * a new cursor. If the range encompass multiple pages the next page in the range
+ * can be queried by update `page.after` to the returned cursor while keeping the
+ * `page.before` cursor from the first range query.
+ *
+ * The `filter` , `columns`,  `sort` , and `page.size` configuration will be
+ * encoded with the cursor.  The pagination request will be invalid if
+ * `filter` or `sort` is set. The columns returned and page size can be changed
+ * anytime by passing the `columns` or `page.size` settings to the next query.
+ *
+ * **Special cursors:**
+ *
+ * - `page.after=end`: Result points past the last entry. The list of records
+ *   returned is empty, but `page.meta.cursor` will include a cursor that can be
+ *   used to "tail" the table from the end waiting for new data to be inserted.
+ * - `page.before=end`: This cursor returns the last page.
+ * - `page.first=<cursor>`: Go to first page. This is equivalent to querying the
+ *   first page without a cursor but `filter` and `sort` . Yet the `page.first`
+ *   cursor can be convenient at times as user code does not need to remember the
+ *   filter, sort, columns or page size configuration. All these information are
+ *   read from the cursor.
+ * - `page.last=<cursor>`: Go to the end of the table. This is equivalent to querying the
+ *   last page with `page.before=end`, `filter`, and `sort` . Yet the
+ *   `page.last` cursor can be more convenient at times as user code does not
+ *   need to remember the filter, sort, columns or page size configuration. All
+ *   these information are read from the cursor.
+ *
+ * When using special cursors like `page.after="end"` or `page.before="end"`, we
+ * still allow `filter` and `sort` to be set.
+ *
+ * Example of getting the last page:
+ *
+ * ```json
+ * POST /db/demo:main/tables/table/query
+ * {
+ *   "page": {
+ *     "size": 10,
+ *     "before": "end"
+ *   }
+ * }
+ * ```
+ */
+const queryTable = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/tables/{tableName}/query', method: 'post' }, variables));
+exports.queryTable = queryTable;
+/**
+ * Run a free text search operation across the database branch.
+ */
+const searchBranch = (variables) => (0, fetcher_1.fetch)(Object.assign({ url: '/db/{dbBranchName}/search', method: 'post' }, variables));
+exports.searchBranch = searchBranch;
+exports.operationsByTag = {
+    users: { getUser: exports.getUser, updateUser: exports.updateUser, deleteUser: exports.deleteUser, getUserAPIKeys: exports.getUserAPIKeys, createUserAPIKey: exports.createUserAPIKey, deleteUserAPIKey: exports.deleteUserAPIKey },
+    workspaces: {
+        createWorkspace: exports.createWorkspace,
+        getWorkspacesList: exports.getWorkspacesList,
+        getWorkspace: exports.getWorkspace,
+        updateWorkspace: exports.updateWorkspace,
+        deleteWorkspace: exports.deleteWorkspace,
+        getWorkspaceMembersList: exports.getWorkspaceMembersList,
+        updateWorkspaceMemberRole: exports.updateWorkspaceMemberRole,
+        removeWorkspaceMember: exports.removeWorkspaceMember,
+        inviteWorkspaceMember: exports.inviteWorkspaceMember,
+        cancelWorkspaceMemberInvite: exports.cancelWorkspaceMemberInvite,
+        resendWorkspaceMemberInvite: exports.resendWorkspaceMemberInvite,
+        acceptWorkspaceMemberInvite: exports.acceptWorkspaceMemberInvite
+    },
+    database: { getDatabaseList: exports.getDatabaseList, createDatabase: exports.createDatabase, deleteDatabase: exports.deleteDatabase },
+    branch: {
+        getBranchList: exports.getBranchList,
+        getBranchDetails: exports.getBranchDetails,
+        createBranch: exports.createBranch,
+        deleteBranch: exports.deleteBranch,
+        updateBranchMetadata: exports.updateBranchMetadata,
+        getBranchMetadata: exports.getBranchMetadata,
+        getBranchMigrationHistory: exports.getBranchMigrationHistory,
+        executeBranchMigrationPlan: exports.executeBranchMigrationPlan,
+        getBranchMigrationPlan: exports.getBranchMigrationPlan,
+        getBranchStats: exports.getBranchStats
+    },
+    table: {
+        createTable: exports.createTable,
+        deleteTable: exports.deleteTable,
+        updateTable: exports.updateTable,
+        getTableSchema: exports.getTableSchema,
+        setTableSchema: exports.setTableSchema,
+        getTableColumns: exports.getTableColumns,
+        addTableColumn: exports.addTableColumn,
+        getColumn: exports.getColumn,
+        deleteColumn: exports.deleteColumn,
+        updateColumn: exports.updateColumn
+    },
+    records: {
+        insertRecord: exports.insertRecord,
+        insertRecordWithID: exports.insertRecordWithID,
+        updateRecordWithID: exports.updateRecordWithID,
+        upsertRecordWithID: exports.upsertRecordWithID,
+        deleteRecord: exports.deleteRecord,
+        getRecord: exports.getRecord,
+        bulkInsertTableRecords: exports.bulkInsertTableRecords,
+        queryTable: exports.queryTable,
+        searchBranch: exports.searchBranch
+    }
+};