class APIError(QuickbaseError)
    def __init__(self, summary: str, *, status_code: int = 0, method: str = '', path: str = '', message: str | None = None, description: str | None = None, request_id: str | None = None) -> None
class App(object)
    def apply_schema_changes(self, plan: SchemaPlan) -> SchemaChangeResult
    def copy(self, name: str, *, description: str | None = None, keep_data: bool = False, keep_files: bool = False, keep_users: bool = False, assign_token: bool = True) -> 'App'
    def create_table(self, name: str, *, description: str | None = None, single_record_name: str | None = None, plural_record_name: str | None = None) -> 'Table'
    def drop(self, *, confirm: str) -> None
    def ensure_table(self, name: str, *, description: str | None = None, single_record_name: str | None = None, plural_record_name: str | None = None) -> 'Table'
    def events(self) -> list[AppEvent]
    property id -> str
    def info(self) -> AppInfo
    def operation(self, name: Literal['describe_schema', 'preview_schema_changes', 'apply_schema_changes'], *, max_changes: int = 20) -> 'SchemaOperation'
    def preview_schema_changes(self, changes: Sequence[CreateTable | UpdateTable | DeleteTable | CreateField | UpdateField | DeleteField | CreateRelationship | CreateLookupField | CreateSummaryField | DeleteRelationship]) -> SchemaPlan
    def roles(self, *, refresh: bool = False) -> list[Role]
    def settings_url(self) -> str
    def table(self, name_or_id: str) -> 'Table'
    def tables(self, *, refresh: bool = False) -> list[TableInfo]
    def url(self) -> str
class AppEvent(object)
    def __eq__(self, other)
    def __init__(self, *, type: str, name: str | None, active: bool, table_id: str | None, url: str | None, owner: User | None, raw: Mapping[str, Any]) -> None
    field active: bool
    field name: str | None
    field owner: User | None
    field raw: Mapping[str, Any]
    property runs_on_changes -> bool
    field table_id: str | None
    field type: str
    field url: str | None
class AppInfo(object)
    def __eq__(self, other)
    def __init__(self, *, id: str, name: str, description: str, time_zone: str | None, date_format: str | None, raw: Mapping[str, Any]) -> None
    field date_format: str | None
    field description: str
    field id: str
    field name: str
    field raw: Mapping[str, Any]
    field time_zone: str | None
class AsyncApp(object)
    async def apply_schema_changes(self, plan: SchemaPlan) -> SchemaChangeResult
    async def copy(self, name: str, *, description: str | None = None, keep_data: bool = False, keep_files: bool = False, keep_users: bool = False, assign_token: bool = True) -> 'AsyncApp'
    async def create_table(self, name: str, *, description: str | None = None, single_record_name: str | None = None, plural_record_name: str | None = None) -> 'AsyncTable'
    async def drop(self, *, confirm: str) -> None
    async def ensure_table(self, name: str, *, description: str | None = None, single_record_name: str | None = None, plural_record_name: str | None = None) -> 'AsyncTable'
    async def events(self) -> list[AppEvent]
    property id -> str
    async def info(self) -> AppInfo
    async def operation(self, name: Literal['describe_schema', 'preview_schema_changes', 'apply_schema_changes'], *, max_changes: int = 20) -> 'AsyncSchemaOperation'
    async def preview_schema_changes(self, changes: Sequence[CreateTable | UpdateTable | DeleteTable | CreateField | UpdateField | DeleteField | CreateRelationship | CreateLookupField | CreateSummaryField | DeleteRelationship]) -> SchemaPlan
    async def roles(self, *, refresh: bool = False) -> list[Role]
    def settings_url(self) -> str
    def table(self, name_or_id: str) -> 'AsyncTable'
    async def tables(self, *, refresh: bool = False) -> list[TableInfo]
    def url(self) -> str
class AsyncOperation(object)
    def __init__(self, table: AsyncTable, spec: OperationSpec) -> None
    property name -> Literal['query', 'count', 'summarize', 'insert', 'update', 'delete', 'preview_update', 'preview_delete', 'run_report', 'run_summary_report', 'run_formula', 'download_file', 'delete_file_version']
    async def run(self, arguments: Mapping[str, Any], *, scope: Expression | None = None) -> Any
    property schema -> dict[str, Any]
class AsyncQuickbase(object)
    async def __aenter__(self) -> Self
    async def __aexit__(self, exc_type: type[BaseException] | None, exc: BaseException | None, traceback: traceback | None) -> None
    def __init__(self, *, realm: str, token: str, base_url: str = 'https://api.quickbase.com/v1', retry: RetryPolicy | None = None, timeout: float = 30.0, user_agent: str | None = None, http_client: httpx.AsyncClient | None = None, schema_ttl: float = 300.0, policy: Policy | BoundPolicy | None = None, confirmation_key: bytes | None = None) -> None
    async def aclose(self) -> None
    def app(self, app_id: str) -> AsyncApp
    def clear_schema_cache(self) -> None
    async def create_app(self, name: str, *, description: str | None = None, assign_token: bool = True) -> AsyncApp
    classmethod def from_env(cls, *, base_url: str = 'https://api.quickbase.com/v1', retry: RetryPolicy | None = None, timeout: float = 30.0, user_agent: str | None = None, http_client: httpx.AsyncClient | None = None, schema_ttl: float = 300.0, policy: Policy | BoundPolicy | None = None, confirmation_key: bytes | None = None, token_env: str = 'QB_USER_TOKEN') -> Self
    property policy -> BoundPolicy | None
    property realm -> str
    async def request(self, method: str, path: str, *, params: Mapping[str, Any] | None = None, json: Any = None) -> Any
class AsyncRecordIterator(object)
    def __aiter__(self) -> Self
    async def __anext__(self) -> Record
    async def to_csv(self, destination: str | os.PathLike[str] | IO[str] | IO[bytes], *, spreadsheet_safe: bool = True, encoding: str = 'utf-8-sig') -> int
    async def to_excel(self, destination: str | os.PathLike[str] | IO[str] | IO[bytes], *, sheet: str = 'Records') -> int
    async def to_pandas(self) -> 'pandas.DataFrame'
    async def to_polars(self) -> 'polars.DataFrame'
class AsyncReport(object)
    async def info(self) -> ReportInfo
    def run(self, *, page_size: int = 1000, max_total: int | None = None) -> AsyncRecordIterator
    async def run_page(self, *, limit: int = 100, skip: int = 0) -> Page
    async def summary_rows(self, *, page_size: int = 1000, max_total: int | None = None) -> list[dict[str, Any]]
    async def url(self, *, edit: bool = False) -> str
class AsyncSchemaOperation(object)
    def __init__(self, app: AsyncApp, name: Literal['describe_schema', 'preview_schema_changes', 'apply_schema_changes'], schema: dict[str, Any], max_changes: int) -> None
    property name -> Literal['describe_schema', 'preview_schema_changes', 'apply_schema_changes']
    async def run(self, arguments: Mapping[str, Any]) -> Any
    property schema -> dict[str, Any]
class AsyncTable(object)
    async def compile_where(self, where: Expression | str) -> str
    async def count(self, where: Expression | str | None = None) -> int
    async def create_field(self, label: str, type: str, *, choices: Sequence[str] | None = None, required: bool | None = None, unique: bool | None = None, properties: Mapping[str, Any] | None = None, formula: str | None = None, help_text: str | None = None, bold: bool | None = None, no_wrap: bool | None = None, find_enabled: bool | None = None, appears_by_default: bool | None = None, add_to_forms: bool | None = None) -> Field
    async def create_relationship(self, parent: 'AsyncTable', *, foreign_key: str, lookup_fields: Sequence[str | int] = ()) -> Relationship
    async def delete(self, where: Expression | str) -> int
    async def delete_fields(self, fields: str | int | Sequence[str | int]) -> None
    async def delete_file_version(self, record_id: int, field: str | int, *, version: int) -> None
    async def delete_relationship(self, relationship: Relationship) -> None
    async def download_file(self, record_id: int, field: str | int, *, version: int | None = None, timeout: float | None = None) -> FileDownload
    async def drop(self, *, confirm: str) -> None
    async def ensure_count_field(self, relationship: Relationship, label: str, *, where: Expression | str | None = None) -> Field
    async def ensure_field(self, label: str, type: str, *, choices: Sequence[str] | None = None, required: bool | None = None, unique: bool | None = None, properties: Mapping[str, Any] | None = None, formula: str | None = None, help_text: str | None = None, bold: bool | None = None, no_wrap: bool | None = None, find_enabled: bool | None = None, appears_by_default: bool | None = None) -> Field
    async def ensure_lookup_field(self, relationship: Relationship, parent_field: str | int, *, label: str | None = None) -> Field
    async def ensure_relationship(self, parent: 'AsyncTable', *, foreign_key: str) -> Relationship
    async def ensure_summary_field(self, relationship: Relationship, child_field: str | int, label: str, *, function: str = 'sum', where: Expression | str | None = None) -> Field
    async def events(self) -> list[AppEvent]
    async def field_url(self, field: str | int) -> str
    async def field_usage(self, fields: str | int | Sequence[str | int] | None = None) -> list[FieldUsage]
    async def fields(self, *, refresh: bool = False) -> list[Field]
    async def fields_url(self) -> str
    async def first(self, *, where: Expression | str | None = None, select: str | int | F | Sequence[str | int | F] | None = None, order_by: str | int | F | Sequence[str | int | F] | None = None) -> Record | None
    async def form_url(self, form_id: int) -> str
    async def get(self, record_id: int, *, select: str | int | F | Sequence[str | int | F] | None = None) -> Record | None
    async def info(self) -> TableInfo
    async def insert(self, records: 'Iterable[Mapping[str | int, Any]] | DataFrame | FileRows', *, batch_size: int = 1000, timeout: float | None = None) -> WriteResult
    async def new_record_url(self) -> str
    async def operation(self, name: Literal['query', 'count', 'summarize', 'insert', 'update', 'delete', 'preview_update', 'preview_delete', 'run_report', 'run_summary_report', 'run_formula', 'download_file', 'delete_file_version'], *, fields: Sequence[str | int] | None = None, field_descriptions: Mapping[str | int, str] | None = None, reports: Sequence[str] | None = None, report_descriptions: Mapping[str, str] | None = None, formula: str | None = None, max_records_per_call: int | None = None, max_records_per_write: int = 100, scope: Expression | None = None, require_preview: bool = False, max_default_fields: int | None = None) -> 'AsyncOperation'
    async def preview_delete(self, where: Expression | str, *, select: str | int | F | Sequence[str | int | F] | None = None, order_by: str | int | F | Sequence[str | int | F] | None = None, limit: int = 100) -> DeletePreview
    async def preview_update(self, records: 'Iterable[Mapping[str | int, Any]] | DataFrame | FileRows') -> UpdatePreview
    def query(self, *, where: Expression | str | None = None, select: str | int | F | Sequence[str | int | F] | None = None, order_by: str | int | F | Sequence[str | int | F] | None = None, page_size: int = 1000, max_total: int | None = None) -> AsyncRecordIterator
    async def query_page(self, *, where: Expression | str | None = None, select: str | int | F | Sequence[str | int | F] | None = None, order_by: str | int | F | Sequence[str | int | F] | None = None, limit: int = 100, skip: int = 0) -> Page
    async def record_url(self, record_id: int, *, edit: bool = False) -> str
    async def record_url_template(self, *, edit: bool = False) -> str
    async def relationships(self, *, refresh: bool = False) -> list[Relationship]
    async def relationships_url(self) -> str
    def report(self, name_or_id: str) -> 'AsyncReport'
    async def reports(self, *, refresh: bool = False) -> list[ReportInfo]
    async def resolve_field_ids(self, fields: Sequence[str | int]) -> list[int]
    async def rows_from_file(self, source: str | os.PathLike[str] | IO[str] | IO[bytes], *, columns: Mapping[str, str | int | None] | None = None, skip_read_only: bool = False, format: Literal['csv', 'xlsx'] | None = None, sheet: str | None = None, tz: datetime.tzinfo = datetime.timezone.utc, date_format: str | None = None, datetime_format: str | None = None, encoding: str = 'utf-8-sig', delimiter: str | None = None, max_rows: int | None = None, max_unzipped_bytes: int | None = 1000000000) -> FileRows
    async def run_formula(self, formula: str, *, record_id: int | None = None) -> FormulaResult
    async def settings_url(self) -> str
    async def summarize(self, group_by: str | int | F | Period | Sequence[str | int | F | Period] | None = None, *, where: Expression | str | None = None, sum: str | int | F | Sequence[str | int | F] | None = None, avg: str | int | F | Sequence[str | int | F] | None = None, median: str | int | F | Sequence[str | int | F] | None = None, std_dev: str | int | F | Sequence[str | int | F] | None = None, min: str | int | F | Sequence[str | int | F] | None = None, max: str | int | F | Sequence[str | int | F] | None = None, distinct_count: str | int | F | Sequence[str | int | F] | None = None, compare_periods: bool = False, max_records_scanned: int | None = None, page_size: int | None = None) -> list[SummaryRow]
    async def update(self, records: 'Iterable[Mapping[str | int, Any]] | DataFrame | FileRows', *, batch_size: int = 1000, timeout: float | None = None) -> WriteResult
    async def update_field(self, field: str | int, *, label: str | None = None, required: bool | None = None, unique: bool | None = None, properties: Mapping[str, Any] | None = None, formula: str | None = None, help_text: str | None = None, bold: bool | None = None, no_wrap: bool | None = None, find_enabled: bool | None = None, appears_by_default: bool | None = None) -> Field
    async def update_info(self, *, name: str | None = None, description: str | None = None, single_record_name: str | None = None, plural_record_name: str | None = None) -> TableInfo
    async def upsert(self, records: 'Iterable[Mapping[str | int, Any]] | DataFrame | FileRows', *, merge_on: str | int, batch_size: int = 1000, timeout: float | None = None) -> WriteResult
    async def url(self) -> str
class AuthenticationError(APIError)
    def __init__(self, summary: str, *, status_code: int = 0, method: str = '', path: str = '', message: str | None = None, description: str | None = None, request_id: str | None = None) -> None
class BadRequestError(APIError)
    def __init__(self, summary: str, *, status_code: int = 0, method: str = '', path: str = '', message: str | None = None, description: str | None = None, request_id: str | None = None) -> None
class BoundPolicy(object)
    def __eq__(self, other: object) -> bool
    def __init__(self, *, app_id: str | None, offline: bool, tables: Mapping[str, str], fields: Mapping[str, Mapping[int, str]], field_types: Mapping[str, Mapping[int, str]], classes: Mapping[str, Mapping[int, frozenset[str]]], rules: Sequence[pyquickbase._bound._Rule], custom: Sequence[Rule], rows: Mapping[str, tuple[str, str]], row_fields: Mapping[str, frozenset[int]], links: Sequence[pyquickbase._bound._Link], reports: Mapping[str, Mapping[str, tuple[str, str]]], new_fields: str, created: Sequence[tuple[str, str]] = ()) -> None
    def allows(self, verb: Literal['read', 'filter', 'sort', 'insert', 'update', 'delete', 'download', 'delete_file', 'report', 'run_formula', 'add_field', 'change_field', 'delete_field', 'formula', 'lookup', 'summary', 'link', 'unlink', 'change_table', 'delete_table', 'create_tables'], table: str, *, field: str | int | None = None, fields: Sequence[str | int] = (), source: tuple[str, str | int] | None = None) -> Decision
    def can_create_tables(self, app_id: str) -> bool
    def classes_of(self, table_id: str, field_id: int) -> frozenset[str]
    property created -> tuple[str, ...]
    property created_offers -> frozenset[str]
    def decide(self, request: ReadRequest | WriteRequest) -> Decision
    def deletion_effects(self, table_id: str, field_ids: Sequence[int] = (), *, table: bool = False) -> tuple[tuple[str, ...], tuple[str, ...]]
    def emails_shown(self, table_id: str) -> bool
    def explain(self, verb: Literal['read', 'filter', 'sort', 'insert', 'update', 'delete', 'download', 'delete_file', 'report', 'run_formula', 'add_field', 'change_field', 'delete_field', 'formula', 'lookup', 'summary', 'link', 'unlink', 'change_table', 'delete_table', 'create_tables'], table: str, *, field: str | int | None = None, fields: Sequence[str | int] = (), source: tuple[str, str | int] | None = None) -> str
    def field_types(self, table_id: str) -> frozenset[str] | None
    def filterable(self, table_id: str, field_id: int) -> bool
    classmethod def from_json(cls, text: str, *, rules: Sequence[Rule] = ()) -> 'BoundPolicy'
    property hash -> str
    def hidden_labels(self, table_id: str) -> frozenset[str]
    def max_delete(self, table_id: str) -> int | None
    def max_records(self, table_id: str) -> int | None
    def max_summary_records(self, table_id: str) -> int | None
    def new_field_effects(self, table_id: str, sources: Sequence[tuple[str, int]] | None = ()) -> tuple[str, ...]
    def offers(self, table: str) -> Offers[Named]
    def offers_for(self, table_id: str, items: Sequence[tuple[~T, str]], field_id: Callable[[~T], int], reports: Sequence[Any] = (), report_key: Callable[[Any], tuple[str, str]] | None = None) -> Offers[~T]
    def readable(self, table_id: str, field_id: int) -> bool
    def row_limit(self, table_id: str) -> str | None
    def row_limit_rule(self, table_id: str) -> str | None
    def schema_tables(self) -> list[Named]
    def table_visible(self, table_id: str) -> bool
    def to_json(self) -> str
    def trim(self, request: ReadRequest | None, method: str, path: str, payload: Any) -> Any
    def user_emails(self, table_id: str) -> bool
    def visible(self, table_id: str, field_id: int) -> bool
    def with_created(self, table_id: str, name: str) -> 'BoundPolicy'
value ColumnMap = Mapping[str, str | int | None]
class ConfigurationError(QuickbaseError, ValueError)
class ConfirmationError(QuickbaseError)
class CreateField(object)
    def __eq__(self, other)
    def __init__(self, *, table: str, label: str, type: str, choices: tuple[str, ...] | None = None, required: bool | None = None, unique: bool | None = None, help_text: str | None = None, formula: str | None = None) -> None
    field choices: tuple[str, ...] | None
    field formula: str | None
    field help_text: str | None
    field label: str
    field required: bool | None
    field table: str
    field type: str
    field unique: bool | None
class CreateLookupField(object)
    def __eq__(self, other)
    def __init__(self, *, child_table: str, foreign_key: str, parent_field: str | int, label: str | None = None) -> None
    field child_table: str
    field foreign_key: str
    field label: str | None
    field parent_field: str | int
class CreateRelationship(object)
    def __eq__(self, other)
    def __init__(self, *, child_table: str, parent_table: str, foreign_key: str) -> None
    field child_table: str
    field foreign_key: str
    field parent_table: str
class CreateSummaryField(object)
    def __eq__(self, other)
    def __init__(self, *, child_table: str, foreign_key: str, label: str, function: Literal['sum', 'avg', 'max', 'min', 'std_dev', 'count', 'distinct_count', 'combined_text', 'combined_user'] = 'sum', child_field: str | int | None = None, where: str | None = None) -> None
    field child_field: str | int | None
    field child_table: str
    field foreign_key: str
    field function: Literal['sum', 'avg', 'max', 'min', 'std_dev', 'count', 'distinct_count', 'combined_text', 'combined_user']
    field label: str
    field where: str | None
class CreateTable(object)
    def __eq__(self, other)
    def __init__(self, *, name: str, description: str | None = None, single_record_name: str | None = None, plural_record_name: str | None = None) -> None
    field description: str | None
    field name: str
    field plural_record_name: str | None
    field single_record_name: str | None
class Decision(object)
    def __eq__(self, other)
    def __init__(self, *, allowed: bool, verb: Literal['read', 'filter', 'sort', 'insert', 'update', 'delete', 'download', 'delete_file', 'report', 'run_formula', 'add_field', 'change_field', 'delete_field', 'formula', 'lookup', 'summary', 'link', 'unlink', 'change_table', 'delete_table', 'create_tables'], layer: Literal['policy', 'rows', 'derived'] = 'policy', rule: str | None = None, reason: str = '', hint: str | None = None, table: Named | None = None, fields: tuple[Named, ...] = ()) -> None
    field allowed: bool
    field fields: tuple[Named, ...]
    field hint: str | None
    field layer: Literal['policy', 'rows', 'derived']
    def message(self) -> str
    field reason: str
    field rule: str | None
    field table: Named | None
    field verb: Literal['read', 'filter', 'sort', 'insert', 'update', 'delete', 'download', 'delete_file', 'report', 'run_formula', 'add_field', 'change_field', 'delete_field', 'formula', 'lookup', 'summary', 'link', 'unlink', 'change_table', 'delete_table', 'create_tables']
    property what -> str
class DeleteField(object)
    def __eq__(self, other)
    def __init__(self, *, table: str, field: str | int) -> None
    field field: str | int
    field table: str
class DeletePreview(Page)
    def __eq__(self, other)
    def __init__(self, *, records: tuple[Record, ...], total: int, skip: int, columns: tuple[str, ...] = (), events: tuple[AppEvent, ...] | None = None) -> None
    field columns: tuple[str, ...]
    field events: tuple[AppEvent, ...] | None
    property has_more -> bool
    property next_skip -> int
    field records: tuple[Record, ...]
    field skip: int
    def to_csv(self, destination: 'FileLike', *, spreadsheet_safe: bool = True, encoding: str = 'utf-8-sig') -> int
    def to_excel(self, destination: 'FileLike', *, sheet: str = 'Records') -> int
    def to_pandas(self) -> 'pandas.DataFrame'
    def to_polars(self) -> 'polars.DataFrame'
    field total: int
class DeleteRelationship(object)
    def __eq__(self, other)
    def __init__(self, *, child_table: str, foreign_key: str) -> None
    field child_table: str
    field foreign_key: str
class DeleteTable(object)
    def __eq__(self, other)
    def __init__(self, *, table: str) -> None
    field table: str
value DerivedKind = Literal['formula', 'lookup', 'summary']
class Expression(object)
    def __and__(self, other: 'Expression') -> 'Group'
    def __bool__(self) -> bool
    def __or__(self, other: 'Expression') -> 'Group'
    def compile(self, fields: FieldIndex) -> str
class F(object)
    def __eq__(self, value: object) -> Condition
    def __ge__(self, value: Any) -> Condition
    def __gt__(self, value: Any) -> Condition
    def __init__(self, field: str | int) -> None
    def __le__(self, value: Any) -> Condition
    def __lt__(self, value: Any) -> Condition
    def __ne__(self, value: object) -> Condition
    def contains(self, value: Any) -> Condition
    def has(self, value: Any) -> Condition
    def is_in(self, values: Iterable[Any]) -> Expression
    def not_contains(self, value: Any) -> Condition
    def not_has(self, value: Any) -> Condition
    def not_starts_with(self, value: Any) -> Condition
    def op(self, operator: str, value: Any) -> Condition
    def starts_with(self, value: Any) -> Condition
class Field(object)
    def __eq__(self, other)
    def __init__(self, *, id: int, label: str, type: str, mode: str | None, required: bool, unique: bool, appears_by_default: bool, choices: tuple[str, ...], allow_new_choices: bool, formula: str | None = None, help_text: str = '', decimal_places: int | None = None, is_foreign_key: bool = False, lookup_reference_field_id: int | None = None, lookup_target_field_id: int | None = None, summary_reference_field_id: int | None = None, summary_target_field_id: int | None = None, summary_function: str | None = None, summary_query: str | None = None, raw: Mapping[str, Any]) -> None
    field allow_new_choices: bool
    field appears_by_default: bool
    field choices: tuple[str, ...]
    field decimal_places: int | None
    field formula: str | None
    field help_text: str
    field id: int
    field is_foreign_key: bool
    field label: str
    field lookup_reference_field_id: int | None
    field lookup_target_field_id: int | None
    field mode: str | None
    field raw: Mapping[str, Any]
    field required: bool
    field summary_function: str | None
    field summary_query: str | None
    field summary_reference_field_id: int | None
    field summary_target_field_id: int | None
    field type: str
    field unique: bool
class FieldChange(object)
    def __eq__(self, other)
    def __init__(self, before: Any, after: Any) -> None
    field after: Any
    field before: Any
value FieldRef = str | int
value FieldRefs = str | int | F | Sequence[str | int | F]
class FieldSelector(object)
    def __eq__(self, other)
    def __init__(self, kind: Literal['all', 'new', 'classed', 'labeled_like', 'named'], values: tuple[str | int, ...] = ()) -> None
    field kind: Literal['all', 'new', 'classed', 'labeled_like', 'named']
    field values: tuple[str | int, ...]
class FieldUsage(object)
    def __eq__(self, other)
    def __init__(self, *, field_id: int, label: str, counts: Mapping[str, int], raw: Mapping[str, Any]) -> None
    field counts: Mapping[str, int]
    def describe(self) -> str
    field field_id: int
    field label: str
    field raw: Mapping[str, Any]
    property total -> int
class FileAttachment(object)
    def __eq__(self, other)
    def __init__(self, *, url: str, versions: tuple[FileVersion, ...]) -> None
    property latest -> FileVersion
    field url: str
    field versions: tuple[FileVersion, ...]
class FileDownload(object)
    def __eq__(self, other)
    def __init__(self, *, file_name: str, data: bytes, content_type: str | None) -> None
    field content_type: str | None
    field data: bytes
    field file_name: str
value FileFormat = Literal['csv', 'xlsx']
value FileLike = str | os.PathLike[str] | IO[str] | IO[bytes]
class FileRowError(object)
    def __eq__(self, other)
    def __init__(self, *, row: int, column: str, message: str) -> None
    field column: str
    field message: str
    field row: int
class FileRows(object)
    def __eq__(self, other)
    def __init__(self, *, rows: tuple[Mapping[str, Any], ...] = (), row_numbers: tuple[int, ...] = (), columns: Mapping[str, str] = <factory>, skipped: tuple[str, ...] = (), errors: tuple[FileRowError, ...] = ()) -> None
    def __iter__(self) -> Iterator[Mapping[str, Any]]
    def __len__(self) -> int
    field columns: Mapping[str, str]
    field errors: tuple[FileRowError, ...]
    property ok -> bool
    def raise_for_errors(self) -> None
    field row_numbers: tuple[int, ...]
    field rows: tuple[Mapping[str, Any], ...]
    field skipped: tuple[str, ...]
class FileTooLargeError(InvalidValueError)
    def __init__(self, limit: int, unit: Literal['rows', 'bytes']) -> None
class FileUpload(object)
    def __eq__(self, other)
    def __init__(self, file_name: str, data: bytes) -> None
    field data: bytes
    field file_name: str
class FileVersion(object)
    def __eq__(self, other)
    def __init__(self, *, number: int, file_name: str, uploaded: datetime.datetime | None, creator: User | None) -> None
    field creator: User | None
    field file_name: str
    field number: int
    field uploaded: datetime.datetime | None
class FormulaResult(object)
    def __eq__(self, other)
    def __init__(self, *, text: str, type: str) -> None
    field text: str
    field type: str
    property value -> Any
class InvalidResponseError(QuickbaseError)
class InvalidValueError(QuickbaseError, ValueError)
value Layer = Literal['policy', 'rows', 'derived']
class Named(object)
    def __eq__(self, other)
    def __init__(self, id: str | int, name: str) -> None
    field id: str | int
    field name: str
class NetworkError(QuickbaseError)
class NotFoundError(APIError)
    def __init__(self, summary: str, *, status_code: int = 0, method: str = '', path: str = '', message: str | None = None, description: str | None = None, request_id: str | None = None) -> None
class Offers(Generic)
    def __eq__(self, other)
    def __init__(self, *, table: Named, readable: tuple[~T, ...] = (), filterable: tuple[~T, ...] = (), sortable: tuple[~T, ...] = (), insertable: tuple[~T, ...] = (), updatable: tuple[~T, ...] = (), downloadable: tuple[~T, ...] = (), file_deletable: tuple[~T, ...] = (), can_delete: bool = False, reports: tuple[Any, ...] = (), schema: frozenset[str] = frozenset(), field_types: frozenset[str] | None = None, max_paging_depth: int | None = None, max_records_scanned: int | None = None, max_records_per_delete: int | None = None, user_emails: bool = False, row_limit: str | None = None) -> None
    field can_delete: bool
    field downloadable: tuple[~T, ...]
    field field_types: frozenset[str] | None
    field file_deletable: tuple[~T, ...]
    field filterable: tuple[~T, ...]
    field insertable: tuple[~T, ...]
    field max_paging_depth: int | None
    field max_records_per_delete: int | None
    field max_records_scanned: int | None
    field readable: tuple[~T, ...]
    field reports: tuple[Any, ...]
    field row_limit: str | None
    field schema: frozenset[str]
    field sortable: tuple[~T, ...]
    field table: Named
    field updatable: tuple[~T, ...]
    field user_emails: bool
class Operation(object)
    def __init__(self, table: Table, spec: OperationSpec) -> None
    property name -> Literal['query', 'count', 'summarize', 'insert', 'update', 'delete', 'preview_update', 'preview_delete', 'run_report', 'run_summary_report', 'run_formula', 'download_file', 'delete_file_version']
    def run(self, arguments: Mapping[str, Any], *, scope: Expression | None = None) -> Any
    property schema -> dict[str, Any]
value OperationName = Literal['query', 'count', 'summarize', 'insert', 'update', 'delete', 'preview_update', 'preview_delete', 'run_report', 'run_summary_report', 'run_formula', 'download_file', 'delete_file_version']
class Page(object)
    def __eq__(self, other)
    def __init__(self, *, records: tuple[Record, ...], total: int, skip: int, columns: tuple[str, ...] = ()) -> None
    field columns: tuple[str, ...]
    property has_more -> bool
    property next_skip -> int
    field records: tuple[Record, ...]
    field skip: int
    def to_csv(self, destination: 'FileLike', *, spreadsheet_safe: bool = True, encoding: str = 'utf-8-sig') -> int
    def to_excel(self, destination: 'FileLike', *, sheet: str = 'Records') -> int
    def to_pandas(self) -> 'pandas.DataFrame'
    def to_polars(self) -> 'polars.DataFrame'
    field total: int
class Period(object)
    def __eq__(self, other)
    def __init__(self, field: str | int | F, unit: Literal['day', 'week', 'month', 'quarter', 'year'], tz: datetime.tzinfo = datetime.timezone.utc) -> None
    field field: str | int | F
    field tz: tzinfo
    field unit: Literal['day', 'week', 'month', 'quarter', 'year']
class PeriodChange(object)
    def __eq__(self, other)
    def __init__(self, *, previous: str, count: int, values: Mapping[str, Mapping[str, float | None]] = <factory>) -> None
    field count: int
    field previous: str
    field values: Mapping[str, Mapping[str, float | None]]
value PeriodUnit = Literal['day', 'week', 'month', 'quarter', 'year']
class PermissionDeniedError(APIError)
    def __init__(self, summary: str, *, status_code: int = 0, method: str = '', path: str = '', message: str | None = None, description: str | None = None, request_id: str | None = None) -> None
class PlannedChange(object)
    def __eq__(self, other)
    def __init__(self, *, change: CreateTable | UpdateTable | DeleteTable | CreateField | UpdateField | DeleteField | CreateRelationship | CreateLookupField | CreateSummaryField | DeleteRelationship, status: Literal['ready', 'already_done', 'blocked'], risk: Literal['additive', 'modifying', 'destructive'], summary: str, settings: Mapping[str, SettingChange] = <factory>, warnings: tuple[str, ...] = (), blockers: tuple[str, ...] = (), affected_records: int | None = None, link: str | None = None, policy_effects: tuple[str, ...] = ()) -> None
    field affected_records: int | None
    field blockers: tuple[str, ...]
    field change: CreateTable | UpdateTable | DeleteTable | CreateField | UpdateField | DeleteField | CreateRelationship | CreateLookupField | CreateSummaryField | DeleteRelationship
    field link: str | None
    field policy_effects: tuple[str, ...]
    field risk: Literal['additive', 'modifying', 'destructive']
    field settings: Mapping[str, SettingChange]
    field status: Literal['ready', 'already_done', 'blocked']
    field summary: str
    field warnings: tuple[str, ...]
class Policy(object)
    def __init__(self, *, app: str | None = None, classes: Mapping[str, Sequence[str | tuple[str, str | int] | FieldSelector]] | None = None, rules: Sequence[PolicyRule | Rule] = (), new_fields: Literal['read', 'hidden'] | str = 'read') -> None
    def bind(self, app: 'App | AsyncApp') -> Any
    def bind_offline(self) -> 'BoundPolicy'
    property needs_app -> bool
    classmethod def read_only(cls) -> 'Policy'
class PolicyRefusedError(QuickbaseError)
    def __init__(self, decision: Any) -> None
class PolicyRule(object)
    def __eq__(self, other)
    def __init__(self, *, effect: Literal['allow', 'deny', 'limit'], tables: tuple[TableSelector, ...] | None, grants: tuple[Grant, ...], options: Mapping[str, Any] = <factory>, text: str) -> None
    field effect: Literal['allow', 'deny', 'limit']
    field grants: tuple[Grant, ...]
    field options: Mapping[str, Any]
    field tables: tuple[TableSelector, ...] | None
    field text: str
class QueryError(QuickbaseError, ValueError)
class Quickbase(object)
    def __enter__(self) -> Self
    def __exit__(self, exc_type: type[BaseException] | None, exc: BaseException | None, traceback: traceback | None) -> None
    def __init__(self, *, realm: str, token: str, base_url: str = 'https://api.quickbase.com/v1', retry: RetryPolicy | None = None, timeout: float = 30.0, user_agent: str | None = None, http_client: httpx.Client | None = None, schema_ttl: float = 300.0, policy: Policy | BoundPolicy | None = None, confirmation_key: bytes | None = None) -> None
    def app(self, app_id: str) -> App
    def clear_schema_cache(self) -> None
    def close(self) -> None
    def create_app(self, name: str, *, description: str | None = None, assign_token: bool = True) -> App
    classmethod def from_env(cls, *, base_url: str = 'https://api.quickbase.com/v1', retry: RetryPolicy | None = None, timeout: float = 30.0, user_agent: str | None = None, http_client: httpx.Client | None = None, schema_ttl: float = 300.0, policy: Policy | BoundPolicy | None = None, confirmation_key: bytes | None = None, token_env: str = 'QB_USER_TOKEN') -> Self
    property policy -> BoundPolicy | None
    property realm -> str
    def request(self, method: str, path: str, *, params: Mapping[str, Any] | None = None, json: Any = None) -> Any
class QuickbaseError(Exception)
class RateLimitError(APIError)
    def __init__(self, summary: str, *, retry_after: float | None = None, **kwargs: object) -> None
value ReadAction = Literal['query', 'summarize', 'delete', 'report', 'summary_report', 'file', 'formula', 'tables', 'fields', 'relationships', 'reports', 'app', 'roles', 'field_usage', 'app_events', 'other']
class ReadRequest(object)
    def __eq__(self, other)
    def __init__(self, *, action: Literal['query', 'summarize', 'delete', 'report', 'summary_report', 'file', 'formula', 'tables', 'fields', 'relationships', 'reports', 'app', 'roles', 'field_usage', 'app_events', 'other'], table_id: str | None = None, field_ids: frozenset[int] | None = None, filter_field_ids: frozenset[int] | None = None, sort_field_ids: frozenset[int] | None = None, limit: int | None = None, skip: int | None = None, report_id: str | None = None, method: str, path: str) -> None
    field action: Literal['query', 'summarize', 'delete', 'report', 'summary_report', 'file', 'formula', 'tables', 'fields', 'relationships', 'reports', 'app', 'roles', 'field_usage', 'app_events', 'other']
    field field_ids: frozenset[int] | None
    field filter_field_ids: frozenset[int] | None
    field limit: int | None
    field method: str
    field path: str
    field report_id: str | None
    field skip: int | None
    field sort_field_ids: frozenset[int] | None
    field table_id: str | None
class Record(Mapping)
    def __getitem__(self, key: str | int) -> Any
    def __init__(self, values: Mapping[int, Any], labels: Mapping[str, int]) -> None
    def __iter__(self) -> Iterator[str | int]
    def __len__(self) -> int
    property id -> int
class RecordChange(object)
    def __eq__(self, other)
    def __init__(self, *, record_id: int, fields: Mapping[str, FieldChange]) -> None
    field fields: Mapping[str, FieldChange]
    field record_id: int
class RecordIterator(object)
    def __iter__(self) -> Self
    def __next__(self) -> Record
    def to_csv(self, destination: str | os.PathLike[str] | IO[str] | IO[bytes], *, spreadsheet_safe: bool = True, encoding: str = 'utf-8-sig') -> int
    def to_excel(self, destination: str | os.PathLike[str] | IO[str] | IO[bytes], *, sheet: str = 'Records') -> int
    def to_pandas(self) -> 'pandas.DataFrame'
    def to_polars(self) -> 'polars.DataFrame'
class Relationship(object)
    def __eq__(self, other)
    def __init__(self, *, id: int, parent_table_id: str, child_table_id: str, foreign_key_field_id: int | None, lookup_field_ids: tuple[int, ...], summary_field_ids: tuple[int, ...] = (), is_cross_app: bool, raw: Mapping[str, Any]) -> None
    field child_table_id: str
    field foreign_key_field_id: int | None
    field id: int
    field is_cross_app: bool
    field lookup_field_ids: tuple[int, ...]
    field parent_table_id: str
    field raw: Mapping[str, Any]
    field summary_field_ids: tuple[int, ...]
class Report(object)
    def info(self) -> ReportInfo
    def run(self, *, page_size: int = 1000, max_total: int | None = None) -> RecordIterator
    def run_page(self, *, limit: int = 100, skip: int = 0) -> Page
    def summary_rows(self, *, page_size: int = 1000, max_total: int | None = None) -> list[dict[str, Any]]
    def url(self, *, edit: bool = False) -> str
class ReportInfo(object)
    def __eq__(self, other)
    def __init__(self, *, id: str, name: str, type: str, description: str, incomplete: bool, raw: Mapping[str, Any]) -> None
    field description: str
    field id: str
    field incomplete: bool
    field name: str
    field raw: Mapping[str, Any]
    field type: str
class RequestTimeoutError(NetworkError)
class RetryPolicy(object)
    def __eq__(self, other)
    def __init__(self, *, max_retries: int = 4, base_delay: float = 1.0, max_delay: float = 30.0, max_retry_after: float = 60.0) -> None
    def backoff(self, attempt: int) -> float
    field base_delay: float
    field max_delay: float
    field max_retries: int
    field max_retry_after: float
    def rate_limit_delay(self, attempt: int, retry_after: float | None) -> float | None
value Risk = Literal['additive', 'modifying', 'destructive']
class Role(object)
    def __eq__(self, other)
    def __init__(self, *, id: int, name: str, access: str, raw: Mapping[str, Any]) -> None
    field access: str
    field id: int
    field name: str
    field raw: Mapping[str, Any]
class RowError(object)
    def __eq__(self, other)
    def __init__(self, *, index: int, messages: tuple[str, ...], reason: Literal['duplicate', 'permission', 'invalid_choice', 'rule', 'other'] = 'other', field_id: int | None = None) -> None
    field field_id: int | None
    field index: int
    field messages: tuple[str, ...]
    field reason: Literal['duplicate', 'permission', 'invalid_choice', 'rule', 'other']
class Rule(Protocol)
    def __init__(self, *args, **kwargs)
    def decide(self, request: 'ReadRequest | WriteRequest') -> Decision | None
value SchemaAction = Literal['create_table', 'update_table', 'delete_table', 'create_field', 'update_field', 'delete_field', 'create_relationship', 'create_lookup_field', 'create_summary_field', 'delete_relationship']
value SchemaChange = CreateTable | UpdateTable | DeleteTable | CreateField | UpdateField | DeleteField | CreateRelationship | CreateLookupField | CreateSummaryField | DeleteRelationship
class SchemaChangeError(WriteError)
    def __init__(self, summary: str, *, result: Any = None) -> None
class SchemaChangeResult(object)
    def __eq__(self, other)
    def __init__(self, *, applied: tuple[PlannedChange, ...] = (), already_done: tuple[PlannedChange, ...] = (), failed: PlannedChange | None = None, not_attempted: tuple[PlannedChange, ...] = (), error: str | None = None) -> None
    field already_done: tuple[PlannedChange, ...]
    field applied: tuple[PlannedChange, ...]
    field error: str | None
    field failed: PlannedChange | None
    field not_attempted: tuple[PlannedChange, ...]
class SchemaMismatchError(QuickbaseError)
class SchemaOperation(object)
    def __init__(self, app: App, name: Literal['describe_schema', 'preview_schema_changes', 'apply_schema_changes'], schema: dict[str, Any], max_changes: int) -> None
    property name -> Literal['describe_schema', 'preview_schema_changes', 'apply_schema_changes']
    def run(self, arguments: Mapping[str, Any]) -> Any
    property schema -> dict[str, Any]
value SchemaOperationName = Literal['describe_schema', 'preview_schema_changes', 'apply_schema_changes']
class SchemaPlan(object)
    def __eq__(self, other)
    def __init__(self, *, app_id: str, changes: tuple[PlannedChange, ...], fingerprint: str, confirmation: str = '') -> None
    field app_id: str
    property blockers -> tuple[str, ...]
    field changes: tuple[PlannedChange, ...]
    field confirmation: str
    field fingerprint: str
    property has_changes -> bool
    property warnings -> tuple[str, ...]
value SchemaVerb = Literal['add_field', 'change_field', 'delete_field', 'formula', 'lookup', 'summary', 'link', 'unlink', 'change_table', 'delete_table']
class ServerError(APIError)
    def __init__(self, summary: str, *, status_code: int = 0, method: str = '', path: str = '', message: str | None = None, description: str | None = None, request_id: str | None = None) -> None
class SettingChange(object)
    def __eq__(self, other)
    def __init__(self, before: Any, after: Any) -> None
    field after: Any
    field before: Any
value StatisticName = Literal['sum', 'avg', 'median', 'std_dev', 'min', 'max', 'distinct_count']
value SummaryFunction = Literal['sum', 'avg', 'max', 'min', 'std_dev', 'count', 'distinct_count', 'combined_text', 'combined_user']
value SummaryGroups = str | int | F | Period | Sequence[str | int | F | Period]
class SummaryRow(object)
    def __eq__(self, other)
    def __init__(self, *, group: Mapping[str, Any] = <factory>, count: int = 0, sum: Mapping[str, float] = <factory>, avg: Mapping[str, float | None] = <factory>, median: Mapping[str, float | None] = <factory>, std_dev: Mapping[str, float | None] = <factory>, min: Mapping[str, Any] = <factory>, max: Mapping[str, Any] = <factory>, distinct_count: Mapping[str, int] = <factory>, change: PeriodChange | None = None) -> None
    field avg: Mapping[str, float | None]
    field change: PeriodChange | None
    field count: int
    field distinct_count: Mapping[str, int]
    field group: Mapping[str, Any]
    field max: Mapping[str, Any]
    field median: Mapping[str, float | None]
    field min: Mapping[str, Any]
    def statistic(self, name: Literal['sum', 'avg', 'median', 'std_dev', 'min', 'max', 'distinct_count']) -> Mapping[str, Any]
    field std_dev: Mapping[str, float | None]
    field sum: Mapping[str, float]
class Table(object)
    def compile_where(self, where: Expression | str) -> str
    def count(self, where: Expression | str | None = None) -> int
    def create_field(self, label: str, type: str, *, choices: Sequence[str] | None = None, required: bool | None = None, unique: bool | None = None, properties: Mapping[str, Any] | None = None, formula: str | None = None, help_text: str | None = None, bold: bool | None = None, no_wrap: bool | None = None, find_enabled: bool | None = None, appears_by_default: bool | None = None, add_to_forms: bool | None = None) -> Field
    def create_relationship(self, parent: 'Table', *, foreign_key: str, lookup_fields: Sequence[str | int] = ()) -> Relationship
    def delete(self, where: Expression | str) -> int
    def delete_fields(self, fields: str | int | Sequence[str | int]) -> None
    def delete_file_version(self, record_id: int, field: str | int, *, version: int) -> None
    def delete_relationship(self, relationship: Relationship) -> None
    def download_file(self, record_id: int, field: str | int, *, version: int | None = None, timeout: float | None = None) -> FileDownload
    def drop(self, *, confirm: str) -> None
    def ensure_count_field(self, relationship: Relationship, label: str, *, where: Expression | str | None = None) -> Field
    def ensure_field(self, label: str, type: str, *, choices: Sequence[str] | None = None, required: bool | None = None, unique: bool | None = None, properties: Mapping[str, Any] | None = None, formula: str | None = None, help_text: str | None = None, bold: bool | None = None, no_wrap: bool | None = None, find_enabled: bool | None = None, appears_by_default: bool | None = None) -> Field
    def ensure_lookup_field(self, relationship: Relationship, parent_field: str | int, *, label: str | None = None) -> Field
    def ensure_relationship(self, parent: 'Table', *, foreign_key: str) -> Relationship
    def ensure_summary_field(self, relationship: Relationship, child_field: str | int, label: str, *, function: str = 'sum', where: Expression | str | None = None) -> Field
    def events(self) -> list[AppEvent]
    def field_url(self, field: str | int) -> str
    def field_usage(self, fields: str | int | Sequence[str | int] | None = None) -> list[FieldUsage]
    def fields(self, *, refresh: bool = False) -> list[Field]
    def fields_url(self) -> str
    def first(self, *, where: Expression | str | None = None, select: str | int | F | Sequence[str | int | F] | None = None, order_by: str | int | F | Sequence[str | int | F] | None = None) -> Record | None
    def form_url(self, form_id: int) -> str
    def get(self, record_id: int, *, select: str | int | F | Sequence[str | int | F] | None = None) -> Record | None
    def info(self) -> TableInfo
    def insert(self, records: 'Iterable[Mapping[str | int, Any]] | DataFrame | FileRows', *, batch_size: int = 1000, timeout: float | None = None) -> WriteResult
    def new_record_url(self) -> str
    def operation(self, name: Literal['query', 'count', 'summarize', 'insert', 'update', 'delete', 'preview_update', 'preview_delete', 'run_report', 'run_summary_report', 'run_formula', 'download_file', 'delete_file_version'], *, fields: Sequence[str | int] | None = None, field_descriptions: Mapping[str | int, str] | None = None, reports: Sequence[str] | None = None, report_descriptions: Mapping[str, str] | None = None, formula: str | None = None, max_records_per_call: int | None = None, max_records_per_write: int = 100, scope: Expression | None = None, require_preview: bool = False, max_default_fields: int | None = None) -> 'Operation'
    def preview_delete(self, where: Expression | str, *, select: str | int | F | Sequence[str | int | F] | None = None, order_by: str | int | F | Sequence[str | int | F] | None = None, limit: int = 100) -> DeletePreview
    def preview_update(self, records: 'Iterable[Mapping[str | int, Any]] | DataFrame | FileRows') -> UpdatePreview
    def query(self, *, where: Expression | str | None = None, select: str | int | F | Sequence[str | int | F] | None = None, order_by: str | int | F | Sequence[str | int | F] | None = None, page_size: int = 1000, max_total: int | None = None) -> RecordIterator
    def query_page(self, *, where: Expression | str | None = None, select: str | int | F | Sequence[str | int | F] | None = None, order_by: str | int | F | Sequence[str | int | F] | None = None, limit: int = 100, skip: int = 0) -> Page
    def record_url(self, record_id: int, *, edit: bool = False) -> str
    def record_url_template(self, *, edit: bool = False) -> str
    def relationships(self, *, refresh: bool = False) -> list[Relationship]
    def relationships_url(self) -> str
    def report(self, name_or_id: str) -> 'Report'
    def reports(self, *, refresh: bool = False) -> list[ReportInfo]
    def resolve_field_ids(self, fields: Sequence[str | int]) -> list[int]
    def rows_from_file(self, source: str | os.PathLike[str] | IO[str] | IO[bytes], *, columns: Mapping[str, str | int | None] | None = None, skip_read_only: bool = False, format: Literal['csv', 'xlsx'] | None = None, sheet: str | None = None, tz: datetime.tzinfo = datetime.timezone.utc, date_format: str | None = None, datetime_format: str | None = None, encoding: str = 'utf-8-sig', delimiter: str | None = None, max_rows: int | None = None, max_unzipped_bytes: int | None = 1000000000) -> FileRows
    def run_formula(self, formula: str, *, record_id: int | None = None) -> FormulaResult
    def settings_url(self) -> str
    def summarize(self, group_by: str | int | F | Period | Sequence[str | int | F | Period] | None = None, *, where: Expression | str | None = None, sum: str | int | F | Sequence[str | int | F] | None = None, avg: str | int | F | Sequence[str | int | F] | None = None, median: str | int | F | Sequence[str | int | F] | None = None, std_dev: str | int | F | Sequence[str | int | F] | None = None, min: str | int | F | Sequence[str | int | F] | None = None, max: str | int | F | Sequence[str | int | F] | None = None, distinct_count: str | int | F | Sequence[str | int | F] | None = None, compare_periods: bool = False, max_records_scanned: int | None = None, page_size: int | None = None) -> list[SummaryRow]
    def update(self, records: 'Iterable[Mapping[str | int, Any]] | DataFrame | FileRows', *, batch_size: int = 1000, timeout: float | None = None) -> WriteResult
    def update_field(self, field: str | int, *, label: str | None = None, required: bool | None = None, unique: bool | None = None, properties: Mapping[str, Any] | None = None, formula: str | None = None, help_text: str | None = None, bold: bool | None = None, no_wrap: bool | None = None, find_enabled: bool | None = None, appears_by_default: bool | None = None) -> Field
    def update_info(self, *, name: str | None = None, description: str | None = None, single_record_name: str | None = None, plural_record_name: str | None = None) -> TableInfo
    def upsert(self, records: 'Iterable[Mapping[str | int, Any]] | DataFrame | FileRows', *, merge_on: str | int, batch_size: int = 1000, timeout: float | None = None) -> WriteResult
    def url(self) -> str
class TableInfo(object)
    def __eq__(self, other)
    def __init__(self, *, id: str, name: str, description: str, key_field_id: int | None, raw: Mapping[str, Any]) -> None
    field description: str
    field id: str
    field key_field_id: int | None
    field name: str
    field raw: Mapping[str, Any]
class TableSchema(object)
    def __eq__(self, other)
    def __init__(self, *, info: TableInfo, fields: tuple[Field, ...], relationships: tuple[Relationship, ...] = ()) -> None
    field fields: tuple[Field, ...]
    field info: TableInfo
    field relationships: tuple[Relationship, ...]
class TableSelector(object)
    def __eq__(self, other)
    def __init__(self, kind: Literal['all', 'created', 'named'], values: tuple[str, ...] = ()) -> None
    field kind: Literal['all', 'created', 'named']
    field values: tuple[str, ...]
class TooManyRecordsError(QueryError)
    def __init__(self, matched: int, limit: int) -> None
value ToolErrorCode = Literal['misconfigured', 'needs_confirmation', 'invalid_arguments', 'too_many_records', 'invalid_value', 'read_refused', 'write_refused', 'unknown_table', 'unknown_field', 'unknown_report', 'unsupported_report', 'schema_mismatch', 'partial_write', 'write_failed', 'write_permission_denied', 'authentication', 'permission_denied', 'not_found', 'bad_request', 'rate_limited', 'server_error', 'api_error', 'timeout', 'network_error', 'invalid_response', 'quickbase_error', 'internal']
class UnknownFieldError(QuickbaseError, LookupError)
class UnknownReportError(QuickbaseError, LookupError)
class UnknownTableError(QuickbaseError, LookupError)
class UnsupportedReportError(QuickbaseError)
class UpdateField(object)
    def __eq__(self, other)
    def __init__(self, *, table: str, field: str | int, label: str | None = None, choices: tuple[str, ...] | None = None, required: bool | None = None, unique: bool | None = None, help_text: str | None = None, formula: str | None = None) -> None
    field choices: tuple[str, ...] | None
    field field: str | int
    field formula: str | None
    field help_text: str | None
    field label: str | None
    field required: bool | None
    field table: str
    field unique: bool | None
class UpdatePreview(object)
    def __eq__(self, other)
    def __init__(self, *, changes: tuple[RecordChange, ...] = (), unchanged_ids: tuple[int, ...] = (), missing_ids: tuple[int, ...] = (), events: tuple[AppEvent, ...] | None = None) -> None
    field changes: tuple[RecordChange, ...]
    field events: tuple[AppEvent, ...] | None
    field missing_ids: tuple[int, ...]
    field unchanged_ids: tuple[int, ...]
class UpdateTable(object)
    def __eq__(self, other)
    def __init__(self, *, table: str, name: str | None = None, description: str | None = None, single_record_name: str | None = None, plural_record_name: str | None = None) -> None
    field description: str | None
    field name: str | None
    field plural_record_name: str | None
    field single_record_name: str | None
    field table: str
class User(object)
    def __eq__(self, other)
    def __init__(self, *, id: str, name: str, email: str | None = None, user_name: str | None = None) -> None
    field email: str | None
    field id: str
    field name: str
    field user_name: str | None
value Verb = Literal['read', 'filter', 'sort', 'insert', 'update', 'delete', 'download', 'delete_file', 'report', 'run_formula', 'add_field', 'change_field', 'delete_field', 'formula', 'lookup', 'summary', 'link', 'unlink', 'change_table', 'delete_table', 'create_tables']
class WhereCondition(object)
    def __eq__(self, other)
    def __init__(self, field_id: int, operator: str, value: str) -> None
    field field_id: int
    field operator: str
    field value: str
value WriteAction = Literal['insert', 'update', 'upsert', 'delete', 'delete_file', 'create_table', 'update_table', 'delete_table', 'create_field', 'update_field', 'delete_field', 'create_relationship', 'update_relationship', 'delete_relationship', 'create_app', 'copy_app', 'delete_app', 'other']
class WriteError(QuickbaseError)
    def __init__(self, summary: str, *, result: Any = None) -> None
class WritePermissionError(WriteError, PermissionDeniedError)
    def __init__(self, summary: str, *, result: Any = None, status_code: int = 403, **kwargs: Any) -> None
class WriteRequest(object)
    def __eq__(self, other)
    def __init__(self, *, action: Literal['insert', 'update', 'upsert', 'delete', 'delete_file', 'create_table', 'update_table', 'delete_table', 'create_field', 'update_field', 'delete_field', 'create_relationship', 'update_relationship', 'delete_relationship', 'create_app', 'copy_app', 'delete_app', 'other'], table_id: str | None, field_ids: frozenset[int] | None, row_count: int | None, method: str, path: str, app_id: str | None = None, parent_table_id: str | None = None, field_type: str | None = None, derived: frozenset[Literal['formula', 'lookup', 'summary']] = frozenset()) -> None
    field action: Literal['insert', 'update', 'upsert', 'delete', 'delete_file', 'create_table', 'update_table', 'delete_table', 'create_field', 'update_field', 'delete_field', 'create_relationship', 'update_relationship', 'delete_relationship', 'create_app', 'copy_app', 'delete_app', 'other']
    field app_id: str | None
    field derived: frozenset[Literal['formula', 'lookup', 'summary']]
    field field_ids: frozenset[int] | None
    field field_type: str | None
    field method: str
    field parent_table_id: str | None
    field path: str
    field row_count: int | None
    field table_id: str | None
class WriteResult(object)
    def __eq__(self, other)
    def __init__(self, *, created_ids: tuple[int, ...] = (), updated_ids: tuple[int, ...] = (), unchanged_ids: tuple[int, ...] = (), errors: tuple[RowError, ...] = (), row_ids: tuple[int | None, ...] = ()) -> None
    field created_ids: tuple[int, ...]
    field errors: tuple[RowError, ...]
    field row_ids: tuple[int | None, ...]
    field unchanged_ids: tuple[int, ...]
    field updated_ids: tuple[int, ...]
value allow = <pyquickbase._policy._AllowOnly object>
value deny = <pyquickbase._policy._Deny object>
value fields = <pyquickbase._policy._Fields object>
value limit = <pyquickbase._policy._Limit object>
def parse_where(where: str, fields: Iterable[Field]) -> list[WhereCondition]
value tables = <pyquickbase._policy._Tables object>
def tool_error(error: BaseException) -> dict[str, Any]
def tool_result(value: Any, *, compact: bool = False, max_records: int | None = None, max_text_chars: int | None = None, max_chars: int | None = None) -> dict[str, Any]
def where_from_dict(data: Mapping[str, Any], *, fields: Iterable[str | int] | Iterable[Field] | None = None) -> Expression
def where_schema(*, fields: Iterable[str | int] | Iterable[Field] | None = None, field_descriptions: Mapping[str | int, str] | None = None, max_depth: int = 2) -> dict[str, Any]
