@xata.io/client 0.2.2 → 0.3.0

package/dist/api/components.d.ts

@@ -0,0 +1,1440 @@
+/**
+ * Generated by @openapi-codegen
+ *
+ * @version 1.0
+ */
+import { FetcherExtraProps } from './fetcher';
+import type * as Schemas from './schemas';
+import type * as Responses from './responses';
+export declare type GetUserVariables = FetcherExtraProps;
+/**
+ * Return details of the user making the request
+ */
+export declare const getUser: (variables: GetUserVariables) => Promise<Schemas.UserWithID>;
+export declare type UpdateUserVariables = {
+    body: Schemas.User;
+} & FetcherExtraProps;
+/**
+ * Update user info
+ */
+export declare const updateUser: (variables: UpdateUserVariables) => Promise<Schemas.UserWithID>;
+export declare type DeleteUserVariables = FetcherExtraProps;
+/**
+ * Delete the user making the request
+ */
+export declare const deleteUser: (variables: DeleteUserVariables) => Promise<undefined>;
+export declare type GetUserAPIKeysResponse = {
+    keys: {
+        name: string;
+        createdAt: Schemas.DateTime;
+    }[];
+};
+export declare type GetUserAPIKeysVariables = FetcherExtraProps;
+/**
+ * Retrieve a list of existing user API keys
+ */
+export declare const getUserAPIKeys: (variables: GetUserAPIKeysVariables) => Promise<GetUserAPIKeysResponse>;
+export declare type CreateUserAPIKeyPathParams = {
+    keyName: Schemas.APIKeyName;
+};
+export declare type CreateUserAPIKeyResponse = {
+    name: string;
+    key: string;
+    createdAt: Schemas.DateTime;
+};
+export declare type CreateUserAPIKeyVariables = {
+    pathParams: CreateUserAPIKeyPathParams;
+} & FetcherExtraProps;
+/**
+ * Create and return new API key
+ */
+export declare const createUserAPIKey: (variables: CreateUserAPIKeyVariables) => Promise<CreateUserAPIKeyResponse>;
+export declare type DeleteUserAPIKeyPathParams = {
+    keyName: Schemas.APIKeyName;
+};
+export declare type DeleteUserAPIKeyVariables = {
+    pathParams: DeleteUserAPIKeyPathParams;
+} & FetcherExtraProps;
+/**
+ * Delete an existing API key
+ */
+export declare const deleteUserAPIKey: (variables: DeleteUserAPIKeyVariables) => Promise<undefined>;
+export declare type CreateWorkspaceVariables = {
+    body: Schemas.WorkspaceMeta;
+} & FetcherExtraProps;
+/**
+ * Creates a new workspace with the user requesting it as its single owner.
+ */
+export declare const createWorkspace: (variables: CreateWorkspaceVariables) => Promise<Schemas.Workspace>;
+export declare type GetWorkspacesListResponse = {
+    workspaces: {
+        id: Schemas.WorkspaceID;
+        name: string;
+        slug: string;
+        role: Schemas.Role;
+    }[];
+};
+export declare type GetWorkspacesListVariables = FetcherExtraProps;
+/**
+ * Retrieve the list of workspaces the user belongs to
+ */
+export declare const getWorkspacesList: (variables: GetWorkspacesListVariables) => Promise<GetWorkspacesListResponse>;
+export declare type GetWorkspacePathParams = {
+    workspaceId: Schemas.WorkspaceID;
+};
+export declare type GetWorkspaceVariables = {
+    pathParams: GetWorkspacePathParams;
+} & FetcherExtraProps;
+/**
+ * Retrieve workspace info from a workspace ID
+ */
+export declare const getWorkspace: (variables: GetWorkspaceVariables) => Promise<Schemas.Workspace>;
+export declare type UpdateWorkspacePathParams = {
+    workspaceId: Schemas.WorkspaceID;
+};
+export declare type UpdateWorkspaceVariables = {
+    body: Schemas.WorkspaceMeta;
+    pathParams: UpdateWorkspacePathParams;
+} & FetcherExtraProps;
+/**
+ * Update workspace info
+ */
+export declare const updateWorkspace: (variables: UpdateWorkspaceVariables) => Promise<Schemas.Workspace>;
+export declare type DeleteWorkspacePathParams = {
+    workspaceId: Schemas.WorkspaceID;
+};
+export declare type DeleteWorkspaceVariables = {
+    pathParams: DeleteWorkspacePathParams;
+} & FetcherExtraProps;
+/**
+ * Delete the workspace with the provided ID
+ */
+export declare const deleteWorkspace: (variables: DeleteWorkspaceVariables) => Promise<undefined>;
+export declare type GetWorkspaceMembersListPathParams = {
+    workspaceId: Schemas.WorkspaceID;
+};
+export declare type GetWorkspaceMembersListVariables = {
+    pathParams: GetWorkspaceMembersListPathParams;
+} & FetcherExtraProps;
+/**
+ * Retrieve the list of members of the given workspace
+ */
+export declare const getWorkspaceMembersList: (variables: GetWorkspaceMembersListVariables) => Promise<Schemas.WorkspaceMembers>;
+export declare type UpdateWorkspaceMemberRolePathParams = {
+    workspaceId: Schemas.WorkspaceID;
+    userId: Schemas.UserID;
+};
+export declare type UpdateWorkspaceMemberRoleRequestBody = {
+    role: Schemas.Role;
+};
+export declare type UpdateWorkspaceMemberRoleVariables = {
+    body: UpdateWorkspaceMemberRoleRequestBody;
+    pathParams: UpdateWorkspaceMemberRolePathParams;
+} & FetcherExtraProps;
+/**
+ * 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.
+ */
+export declare const updateWorkspaceMemberRole: (variables: UpdateWorkspaceMemberRoleVariables) => Promise<undefined>;
+export declare type RemoveWorkspaceMemberPathParams = {
+    workspaceId: Schemas.WorkspaceID;
+    userId: Schemas.UserID;
+};
+export declare type RemoveWorkspaceMemberVariables = {
+    pathParams: RemoveWorkspaceMemberPathParams;
+} & FetcherExtraProps;
+/**
+ * Remove the member from the workspace
+ */
+export declare const removeWorkspaceMember: (variables: RemoveWorkspaceMemberVariables) => Promise<undefined>;
+export declare type InviteWorkspaceMemberPathParams = {
+    workspaceId: Schemas.WorkspaceID;
+};
+export declare type InviteWorkspaceMemberRequestBody = {
+    email: string;
+    role: Schemas.Role;
+};
+export declare type InviteWorkspaceMemberVariables = {
+    body: InviteWorkspaceMemberRequestBody;
+    pathParams: InviteWorkspaceMemberPathParams;
+} & FetcherExtraProps;
+/**
+ * Invite some user to join the workspace with the given role
+ */
+export declare const inviteWorkspaceMember: (variables: InviteWorkspaceMemberVariables) => Promise<Schemas.WorkspaceInvite>;
+export declare type CancelWorkspaceMemberInvitePathParams = {
+    workspaceId: Schemas.WorkspaceID;
+    inviteId: Schemas.InviteID;
+};
+export declare type CancelWorkspaceMemberInviteVariables = {
+    pathParams: CancelWorkspaceMemberInvitePathParams;
+} & FetcherExtraProps;
+/**
+ * This operation provides a way to cancel invites by deleting them. Already accepted invites cannot be deleted.
+ */
+export declare const cancelWorkspaceMemberInvite: (variables: CancelWorkspaceMemberInviteVariables) => Promise<undefined>;
+export declare type ResendWorkspaceMemberInvitePathParams = {
+    workspaceId: Schemas.WorkspaceID;
+    inviteId: Schemas.InviteID;
+};
+export declare type ResendWorkspaceMemberInviteVariables = {
+    pathParams: ResendWorkspaceMemberInvitePathParams;
+} & FetcherExtraProps;
+/**
+ * This operation provides a way to resend an Invite notification. Invite notifications can only be sent for Invites not yet accepted.
+ */
+export declare const resendWorkspaceMemberInvite: (variables: ResendWorkspaceMemberInviteVariables) => Promise<undefined>;
+export declare type AcceptWorkspaceMemberInvitePathParams = {
+    workspaceId: Schemas.WorkspaceID;
+    inviteKey: Schemas.InviteKey;
+};
+export declare type AcceptWorkspaceMemberInviteVariables = {
+    pathParams: AcceptWorkspaceMemberInvitePathParams;
+} & FetcherExtraProps;
+/**
+ * Accept the invitation to join a workspace. If the operation succeeds the user will be a member of the workspace
+ */
+export declare const acceptWorkspaceMemberInvite: (variables: AcceptWorkspaceMemberInviteVariables) => Promise<undefined>;
+export declare type GetDatabaseListPathParams = {
+    workspace: string;
+};
+export declare type GetDatabaseListVariables = {
+    pathParams: GetDatabaseListPathParams;
+} & FetcherExtraProps;
+/**
+ * List all databases available in your Workspace.
+ */
+export declare const getDatabaseList: (variables: GetDatabaseListVariables) => Promise<Schemas.ListDatabasesResponse>;
+export declare type GetBranchListPathParams = {
+    dbName: Schemas.DBName;
+    workspace: string;
+};
+export declare type GetBranchListVariables = {
+    pathParams: GetBranchListPathParams;
+} & FetcherExtraProps;
+/**
+ * List all available Branches
+ */
+export declare const getBranchList: (variables: GetBranchListVariables) => Promise<Schemas.ListBranchesResponse>;
+export declare type CreateDatabasePathParams = {
+    dbName: Schemas.DBName;
+    workspace: string;
+};
+export declare type CreateDatabaseResponse = {
+    databaseName: string;
+    branchName?: string;
+};
+export declare type CreateDatabaseRequestBody = {
+    displayName?: string;
+    branchName?: string;
+    ui?: {
+        color?: string;
+    };
+    metadata?: Schemas.BranchMetadata;
+};
+export declare type CreateDatabaseVariables = {
+    body?: CreateDatabaseRequestBody;
+    pathParams: CreateDatabasePathParams;
+} & FetcherExtraProps;
+/**
+ * Create Database with identifier name
+ */
+export declare const createDatabase: (variables: CreateDatabaseVariables) => Promise<CreateDatabaseResponse>;
+export declare type DeleteDatabasePathParams = {
+    dbName: Schemas.DBName;
+    workspace: string;
+};
+export declare type DeleteDatabaseVariables = {
+    pathParams: DeleteDatabasePathParams;
+} & FetcherExtraProps;
+/**
+ * Delete a database and all of its branches and tables permanently.
+ */
+export declare const deleteDatabase: (variables: DeleteDatabaseVariables) => Promise<undefined>;
+export declare type GetBranchDetailsPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    workspace: string;
+};
+export declare type GetBranchDetailsVariables = {
+    pathParams: GetBranchDetailsPathParams;
+} & FetcherExtraProps;
+export declare const getBranchDetails: (variables: GetBranchDetailsVariables) => Promise<Schemas.DBBranch>;
+export declare type CreateBranchPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    workspace: string;
+};
+export declare type CreateBranchQueryParams = {
+    from?: string;
+};
+export declare type CreateBranchRequestBody = {
+    from?: string;
+    metadata?: Schemas.BranchMetadata;
+};
+export declare type CreateBranchVariables = {
+    body?: CreateBranchRequestBody;
+    pathParams: CreateBranchPathParams;
+    queryParams?: CreateBranchQueryParams;
+} & FetcherExtraProps;
+export declare const createBranch: (variables: CreateBranchVariables) => Promise<undefined>;
+export declare type DeleteBranchPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    workspace: string;
+};
+export declare type DeleteBranchVariables = {
+    pathParams: DeleteBranchPathParams;
+} & FetcherExtraProps;
+/**
+ * Delete the branch in the database and all its resources
+ */
+export declare const deleteBranch: (variables: DeleteBranchVariables) => Promise<undefined>;
+export declare type UpdateBranchMetadataPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    workspace: string;
+};
+export declare type UpdateBranchMetadataVariables = {
+    body?: Schemas.BranchMetadata;
+    pathParams: UpdateBranchMetadataPathParams;
+} & FetcherExtraProps;
+/**
+ * Update the branch metadata
+ */
+export declare const updateBranchMetadata: (variables: UpdateBranchMetadataVariables) => Promise<undefined>;
+export declare type GetBranchMetadataPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    workspace: string;
+};
+export declare type GetBranchMetadataVariables = {
+    pathParams: GetBranchMetadataPathParams;
+} & FetcherExtraProps;
+export declare const getBranchMetadata: (variables: GetBranchMetadataVariables) => Promise<Schemas.BranchMetadata>;
+export declare type GetBranchMigrationHistoryPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    workspace: string;
+};
+export declare type GetBranchMigrationHistoryResponse = {
+    startedFrom?: Schemas.StartedFromMetadata;
+    migrations?: Schemas.BranchMigration[];
+};
+export declare type GetBranchMigrationHistoryRequestBody = {
+    limit?: number;
+    startFrom?: string;
+};
+export declare type GetBranchMigrationHistoryVariables = {
+    body?: GetBranchMigrationHistoryRequestBody;
+    pathParams: GetBranchMigrationHistoryPathParams;
+} & FetcherExtraProps;
+export declare const getBranchMigrationHistory: (variables: GetBranchMigrationHistoryVariables) => Promise<GetBranchMigrationHistoryResponse>;
+export declare type ExecuteBranchMigrationPlanPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    workspace: string;
+};
+export declare type ExecuteBranchMigrationPlanRequestBody = {
+    version: number;
+    migration: Schemas.BranchMigration;
+};
+export declare type ExecuteBranchMigrationPlanVariables = {
+    body: ExecuteBranchMigrationPlanRequestBody;
+    pathParams: ExecuteBranchMigrationPlanPathParams;
+} & FetcherExtraProps;
+/**
+ * Apply a migration plan to the branch
+ */
+export declare const executeBranchMigrationPlan: (variables: ExecuteBranchMigrationPlanVariables) => Promise<undefined>;
+export declare type GetBranchMigrationPlanPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    workspace: string;
+};
+export declare type GetBranchMigrationPlanVariables = {
+    body: Schemas.Schema;
+    pathParams: GetBranchMigrationPlanPathParams;
+} & FetcherExtraProps;
+/**
+ * Compute a migration plan from a target schema the branch should be migrated too.
+ */
+export declare const getBranchMigrationPlan: (variables: GetBranchMigrationPlanVariables) => Promise<Responses.BranchMigrationPlan>;
+export declare type GetBranchStatsPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    workspace: string;
+};
+export declare type GetBranchStatsResponse = {
+    timestamp: string;
+    interval: string;
+    resolution: string;
+    numberOfRecords?: Schemas.MetricsDatapoint[];
+    writesOverTime?: Schemas.MetricsDatapoint[];
+    readsOverTime?: Schemas.MetricsDatapoint[];
+    readLatency?: Schemas.MetricsLatency;
+    writeLatency?: Schemas.MetricsLatency;
+    warning?: string;
+};
+export declare type GetBranchStatsVariables = {
+    pathParams: GetBranchStatsPathParams;
+} & FetcherExtraProps;
+/**
+ * Get branch usage metrics.
+ */
+export declare const getBranchStats: (variables: GetBranchStatsVariables) => Promise<GetBranchStatsResponse>;
+export declare type CreateTablePathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    tableName: Schemas.TableName;
+    workspace: string;
+};
+export declare type CreateTableVariables = {
+    pathParams: CreateTablePathParams;
+} & FetcherExtraProps;
+/**
+ * Creates a new table with the given name. Returns 422 if a table with the same name already exists.
+ */
+export declare const createTable: (variables: CreateTableVariables) => Promise<undefined>;
+export declare type DeleteTablePathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    tableName: Schemas.TableName;
+    workspace: string;
+};
+export declare type DeleteTableVariables = {
+    pathParams: DeleteTablePathParams;
+} & FetcherExtraProps;
+/**
+ * Deletes the table with the given name.
+ */
+export declare const deleteTable: (variables: DeleteTableVariables) => Promise<undefined>;
+export declare type UpdateTablePathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    tableName: Schemas.TableName;
+    workspace: string;
+};
+export declare type UpdateTableRequestBody = {
+    name: string;
+};
+export declare type UpdateTableVariables = {
+    body: UpdateTableRequestBody;
+    pathParams: UpdateTablePathParams;
+} & FetcherExtraProps;
+/**
+ * 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"
+ * }
+ * ```
+ */
+export declare const updateTable: (variables: UpdateTableVariables) => Promise<undefined>;
+export declare type GetTableSchemaPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    tableName: Schemas.TableName;
+    workspace: string;
+};
+export declare type GetTableSchemaResponse = {
+    columns: Schemas.Column[];
+};
+export declare type GetTableSchemaVariables = {
+    pathParams: GetTableSchemaPathParams;
+} & FetcherExtraProps;
+export declare const getTableSchema: (variables: GetTableSchemaVariables) => Promise<GetTableSchemaResponse>;
+export declare type SetTableSchemaPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    tableName: Schemas.TableName;
+    workspace: string;
+};
+export declare type SetTableSchemaRequestBody = {
+    columns: Schemas.Column[];
+};
+export declare type SetTableSchemaVariables = {
+    body: SetTableSchemaRequestBody;
+    pathParams: SetTableSchemaPathParams;
+} & FetcherExtraProps;
+export declare const setTableSchema: (variables: SetTableSchemaVariables) => Promise<undefined>;
+export declare type GetTableColumnsPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    tableName: Schemas.TableName;
+    workspace: string;
+};
+export declare type GetTableColumnsResponse = {
+    columns: Schemas.Column[];
+};
+export declare type GetTableColumnsVariables = {
+    pathParams: GetTableColumnsPathParams;
+} & FetcherExtraProps;
+/**
+ * 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).
+ */
+export declare const getTableColumns: (variables: GetTableColumnsVariables) => Promise<GetTableColumnsResponse>;
+export declare type AddTableColumnPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    tableName: Schemas.TableName;
+    workspace: string;
+};
+export declare type AddTableColumnVariables = {
+    body: Schemas.Column;
+    pathParams: AddTableColumnPathParams;
+} & FetcherExtraProps;
+/**
+ * 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.
+ */
+export declare const addTableColumn: (variables: AddTableColumnVariables) => Promise<Responses.MigrationIdResponse>;
+export declare type GetColumnPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    tableName: Schemas.TableName;
+    columnName: Schemas.ColumnName;
+    workspace: string;
+};
+export declare type GetColumnVariables = {
+    pathParams: GetColumnPathParams;
+} & FetcherExtraProps;
+/**
+ * Get the definition of a single column. To refer to sub-objects, the column name can contain dots. For example `address.country`.
+ */
+export declare const getColumn: (variables: GetColumnVariables) => Promise<Schemas.Column>;
+export declare type DeleteColumnPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    tableName: Schemas.TableName;
+    columnName: Schemas.ColumnName;
+    workspace: string;
+};
+export declare type DeleteColumnVariables = {
+    pathParams: DeleteColumnPathParams;
+} & FetcherExtraProps;
+/**
+ * Deletes the specified column. To refer to sub-objects, the column name can contain dots. For example `address.country`.
+ */
+export declare const deleteColumn: (variables: DeleteColumnVariables) => Promise<Responses.MigrationIdResponse>;
+export declare type UpdateColumnPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    tableName: Schemas.TableName;
+    columnName: Schemas.ColumnName;
+    workspace: string;
+};
+export declare type UpdateColumnRequestBody = {
+    name: string;
+};
+export declare type UpdateColumnVariables = {
+    body: UpdateColumnRequestBody;
+    pathParams: UpdateColumnPathParams;
+} & FetcherExtraProps;
+/**
+ * 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`.
+ */
+export declare const updateColumn: (variables: UpdateColumnVariables) => Promise<Responses.MigrationIdResponse>;
+export declare type InsertRecordPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    tableName: Schemas.TableName;
+    workspace: string;
+};
+export declare type InsertRecordResponse = {
+    id: string;
+    xata: {
+        version: number;
+    };
+};
+export declare type InsertRecordVariables = {
+    body?: Record<string, any>;
+    pathParams: InsertRecordPathParams;
+} & FetcherExtraProps;
+/**
+ * Insert a new Record into the Table
+ */
+export declare const insertRecord: (variables: InsertRecordVariables) => Promise<InsertRecordResponse>;
+export declare type InsertRecordWithIDPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    tableName: Schemas.TableName;
+    recordId: Schemas.RecordID;
+    workspace: string;
+};
+export declare type InsertRecordWithIDQueryParams = {
+    createOnly?: boolean;
+    ifVersion?: number;
+};
+export declare type InsertRecordWithIDVariables = {
+    body?: Record<string, any>;
+    pathParams: InsertRecordWithIDPathParams;
+    queryParams?: InsertRecordWithIDQueryParams;
+} & FetcherExtraProps;
+/**
+ * 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.
+ */
+export declare const insertRecordWithID: (variables: InsertRecordWithIDVariables) => Promise<Responses.RecordUpdateResponse>;
+export declare type UpdateRecordWithIDPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    tableName: Schemas.TableName;
+    recordId: Schemas.RecordID;
+    workspace: string;
+};
+export declare type UpdateRecordWithIDQueryParams = {
+    ifVersion?: number;
+};
+export declare type UpdateRecordWithIDVariables = {
+    body?: Record<string, any>;
+    pathParams: UpdateRecordWithIDPathParams;
+    queryParams?: UpdateRecordWithIDQueryParams;
+} & FetcherExtraProps;
+export declare const updateRecordWithID: (variables: UpdateRecordWithIDVariables) => Promise<Responses.RecordUpdateResponse>;
+export declare type UpsertRecordWithIDPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    tableName: Schemas.TableName;
+    recordId: Schemas.RecordID;
+    workspace: string;
+};
+export declare type UpsertRecordWithIDQueryParams = {
+    ifVersion?: number;
+};
+export declare type UpsertRecordWithIDVariables = {
+    body?: Record<string, any>;
+    pathParams: UpsertRecordWithIDPathParams;
+    queryParams?: UpsertRecordWithIDQueryParams;
+} & FetcherExtraProps;
+export declare const upsertRecordWithID: (variables: UpsertRecordWithIDVariables) => Promise<Responses.RecordUpdateResponse>;
+export declare type DeleteRecordPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    tableName: Schemas.TableName;
+    recordId: Schemas.RecordID;
+    workspace: string;
+};
+export declare type DeleteRecordVariables = {
+    pathParams: DeleteRecordPathParams;
+} & FetcherExtraProps;
+export declare const deleteRecord: (variables: DeleteRecordVariables) => Promise<undefined>;
+export declare type GetRecordPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    tableName: Schemas.TableName;
+    recordId: Schemas.RecordID;
+    workspace: string;
+};
+export declare type GetRecordRequestBody = {
+    columns?: Schemas.ColumnsFilter;
+};
+export declare type GetRecordVariables = {
+    body?: GetRecordRequestBody;
+    pathParams: GetRecordPathParams;
+} & FetcherExtraProps;
+/**
+ * Retrieve record by ID
+ */
+export declare const getRecord: (variables: GetRecordVariables) => Promise<Schemas.XataRecord>;
+export declare type BulkInsertTableRecordsPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    tableName: Schemas.TableName;
+    workspace: string;
+};
+export declare type BulkInsertTableRecordsResponse = {
+    recordIDs: string[];
+};
+export declare type BulkInsertTableRecordsRequestBody = {
+    records: Record<string, any>[];
+};
+export declare type BulkInsertTableRecordsVariables = {
+    body: BulkInsertTableRecordsRequestBody;
+    pathParams: BulkInsertTableRecordsPathParams;
+} & FetcherExtraProps;
+/**
+ * Bulk insert records
+ */
+export declare const bulkInsertTableRecords: (variables: BulkInsertTableRecordsVariables) => Promise<BulkInsertTableRecordsResponse>;
+export declare type QueryTablePathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    tableName: Schemas.TableName;
+    workspace: string;
+};
+export declare type QueryTableRequestBody = {
+    filter?: Schemas.FilterExpression;
+    sort?: Schemas.SortExpression;
+    page?: Schemas.PageConfig;
+    columns?: Schemas.ColumnsFilter;
+};
+export declare type QueryTableVariables = {
+    body?: QueryTableRequestBody;
+    pathParams: QueryTablePathParams;
+} & FetcherExtraProps;
+/**
+ * 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"
+ *   }
+ * }
+ * ```
+ */
+export declare const queryTable: (variables: QueryTableVariables) => Promise<Responses.QueryResponse>;
+export declare type SearchBranchPathParams = {
+    dbBranchName: Schemas.DBBranchName;
+    workspace: string;
+};
+export declare type SearchBranchRequestBody = {
+    tables?: string[];
+    query: string;
+    fuzziness?: number;
+};
+export declare type SearchBranchVariables = {
+    body: SearchBranchRequestBody;
+    pathParams: SearchBranchPathParams;
+} & FetcherExtraProps;
+/**
+ * Run a free text search operation across the database branch.
+ */
+export declare const searchBranch: (variables: SearchBranchVariables) => Promise<Responses.SearchResponse>;
+export declare const operationsByTag: {
+    users: {
+        getUser: (variables: GetUserVariables) => Promise<Schemas.UserWithID>;
+        updateUser: (variables: UpdateUserVariables) => Promise<Schemas.UserWithID>;
+        deleteUser: (variables: DeleteUserVariables) => Promise<undefined>;
+        getUserAPIKeys: (variables: GetUserAPIKeysVariables) => Promise<GetUserAPIKeysResponse>;
+        createUserAPIKey: (variables: CreateUserAPIKeyVariables) => Promise<CreateUserAPIKeyResponse>;
+        deleteUserAPIKey: (variables: DeleteUserAPIKeyVariables) => Promise<undefined>;
+    };
+    workspaces: {
+        createWorkspace: (variables: CreateWorkspaceVariables) => Promise<Schemas.Workspace>;
+        getWorkspacesList: (variables: GetWorkspacesListVariables) => Promise<GetWorkspacesListResponse>;
+        getWorkspace: (variables: GetWorkspaceVariables) => Promise<Schemas.Workspace>;
+        updateWorkspace: (variables: UpdateWorkspaceVariables) => Promise<Schemas.Workspace>;
+        deleteWorkspace: (variables: DeleteWorkspaceVariables) => Promise<undefined>;
+        getWorkspaceMembersList: (variables: GetWorkspaceMembersListVariables) => Promise<Schemas.WorkspaceMembers>;
+        updateWorkspaceMemberRole: (variables: UpdateWorkspaceMemberRoleVariables) => Promise<undefined>;
+        removeWorkspaceMember: (variables: RemoveWorkspaceMemberVariables) => Promise<undefined>;
+        inviteWorkspaceMember: (variables: InviteWorkspaceMemberVariables) => Promise<Schemas.WorkspaceInvite>;
+        cancelWorkspaceMemberInvite: (variables: CancelWorkspaceMemberInviteVariables) => Promise<undefined>;
+        resendWorkspaceMemberInvite: (variables: ResendWorkspaceMemberInviteVariables) => Promise<undefined>;
+        acceptWorkspaceMemberInvite: (variables: AcceptWorkspaceMemberInviteVariables) => Promise<undefined>;
+    };
+    database: {
+        getDatabaseList: (variables: GetDatabaseListVariables) => Promise<Schemas.ListDatabasesResponse>;
+        createDatabase: (variables: CreateDatabaseVariables) => Promise<CreateDatabaseResponse>;
+        deleteDatabase: (variables: DeleteDatabaseVariables) => Promise<undefined>;
+    };
+    branch: {
+        getBranchList: (variables: GetBranchListVariables) => Promise<Schemas.ListBranchesResponse>;
+        getBranchDetails: (variables: GetBranchDetailsVariables) => Promise<Schemas.DBBranch>;
+        createBranch: (variables: CreateBranchVariables) => Promise<undefined>;
+        deleteBranch: (variables: DeleteBranchVariables) => Promise<undefined>;
+        updateBranchMetadata: (variables: UpdateBranchMetadataVariables) => Promise<undefined>;
+        getBranchMetadata: (variables: GetBranchMetadataVariables) => Promise<Schemas.BranchMetadata>;
+        getBranchMigrationHistory: (variables: GetBranchMigrationHistoryVariables) => Promise<GetBranchMigrationHistoryResponse>;
+        executeBranchMigrationPlan: (variables: ExecuteBranchMigrationPlanVariables) => Promise<undefined>;
+        getBranchMigrationPlan: (variables: GetBranchMigrationPlanVariables) => Promise<Responses.BranchMigrationPlan>;
+        getBranchStats: (variables: GetBranchStatsVariables) => Promise<GetBranchStatsResponse>;
+    };
+    table: {
+        createTable: (variables: CreateTableVariables) => Promise<undefined>;
+        deleteTable: (variables: DeleteTableVariables) => Promise<undefined>;
+        updateTable: (variables: UpdateTableVariables) => Promise<undefined>;
+        getTableSchema: (variables: GetTableSchemaVariables) => Promise<GetTableSchemaResponse>;
+        setTableSchema: (variables: SetTableSchemaVariables) => Promise<undefined>;
+        getTableColumns: (variables: GetTableColumnsVariables) => Promise<GetTableColumnsResponse>;
+        addTableColumn: (variables: AddTableColumnVariables) => Promise<Responses.MigrationIdResponse>;
+        getColumn: (variables: GetColumnVariables) => Promise<Schemas.Column>;
+        deleteColumn: (variables: DeleteColumnVariables) => Promise<Responses.MigrationIdResponse>;
+        updateColumn: (variables: UpdateColumnVariables) => Promise<Responses.MigrationIdResponse>;
+    };
+    records: {
+        insertRecord: (variables: InsertRecordVariables) => Promise<InsertRecordResponse>;
+        insertRecordWithID: (variables: InsertRecordWithIDVariables) => Promise<Responses.RecordUpdateResponse>;
+        updateRecordWithID: (variables: UpdateRecordWithIDVariables) => Promise<Responses.RecordUpdateResponse>;
+        upsertRecordWithID: (variables: UpsertRecordWithIDVariables) => Promise<Responses.RecordUpdateResponse>;
+        deleteRecord: (variables: DeleteRecordVariables) => Promise<undefined>;
+        getRecord: (variables: GetRecordVariables) => Promise<Schemas.XataRecord>;
+        bulkInsertTableRecords: (variables: BulkInsertTableRecordsVariables) => Promise<BulkInsertTableRecordsResponse>;
+        queryTable: (variables: QueryTableVariables) => Promise<Responses.QueryResponse>;
+        searchBranch: (variables: SearchBranchVariables) => Promise<Responses.SearchResponse>;
+    };
+};