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, quickbase_code: int | None = None) -> None
    property doc_url -> str
class App(object)
    def apply_schema_changes(self, plan: SchemaPlan) -> SchemaChangeResult
    def code_page(self, name_or_id: str | int) -> 'CodePage'
    def code_pages(self) -> list[CodePageInfo]
    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_role_assignments(self, assignments: Sequence[RoleAssignment]) -> RoleAssignmentResult
    def create_table(self, name: str, *, description: str | None = None, single_record_name: str | None = None, plural_record_name: str | None = None) -> 'Table'
    def delete_role_assignments(self, assignments: Sequence[RoleAssignment]) -> RoleAssignmentResult
    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'
    property id -> str
    def info(self) -> AppInfo
    def member_roles(self, member_id: str | None = None, *, include_groups: bool = True) -> list[MemberRole]
    def members(self) -> list[AppMember]
    def operation(self, name: Literal['describe_schema', 'preview_schema_changes', 'apply_schema_changes', 'list_code_pages', 'read_code_page', 'preview_code_page_change', 'apply_code_page_change'], *, max_changes: int = 20) -> 'AppOperation'
    def preview_schema_changes(self, changes: Sequence[CreateTable | UpdateTable | DeleteTable | CreateField | UpdateField | DeleteField | SetKeyField | 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 triggers(self) -> list[AppTrigger]
    def update_role_assignments(self, changes: Sequence[RoleAssignmentUpdate]) -> RoleAssignmentResult
    def url(self) -> str
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 AppListing(object)
    def __eq__(self, other)
    def __init__(self, *, id: str, name: str, ancestor_id: str | None, oldest_ancestor_id: str | None, url: str) -> None
    field ancestor_id: str | None
    field id: str
    field name: str
    field oldest_ancestor_id: str | None
    field url: str
class AppMember(object)
    def __eq__(self, other)
    def __init__(self, *, id: str, kind: Literal['user', 'group'], name: str, first_name: str | None, last_name: str | None, last_accessed_at: datetime.datetime | None, roles: tuple[Role, ...]) -> None
    field first_name: str | None
    field id: str
    field kind: Literal['user', 'group']
    field last_accessed_at: datetime.datetime | None
    field last_name: str | None
    field name: str
    field roles: tuple[Role, ...]
class AppOperation(object)
    def __init__(self, app: App, name: Literal['describe_schema', 'preview_schema_changes', 'apply_schema_changes', 'list_code_pages', 'read_code_page', 'preview_code_page_change', 'apply_code_page_change'], input_schema: dict[str, Any], max_changes: int = 20) -> None
    property input_schema -> dict[str, Any]
    property name -> Literal['describe_schema', 'preview_schema_changes', 'apply_schema_changes', 'list_code_pages', 'read_code_page', 'preview_code_page_change', 'apply_code_page_change']
    def run(self, arguments: Mapping[str, Any]) -> Any
value AppOperationName = Literal['describe_schema', 'preview_schema_changes', 'apply_schema_changes', 'list_code_pages', 'read_code_page', 'preview_code_page_change', 'apply_code_page_change']
class AppTrigger(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 AsyncApp(object)
    async def apply_schema_changes(self, plan: SchemaPlan) -> SchemaChangeResult
    def code_page(self, name_or_id: str | int) -> 'AsyncCodePage'
    async def code_pages(self) -> list[CodePageInfo]
    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_role_assignments(self, assignments: Sequence[RoleAssignment]) -> RoleAssignmentResult
    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 delete_role_assignments(self, assignments: Sequence[RoleAssignment]) -> RoleAssignmentResult
    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'
    property id -> str
    async def info(self) -> AppInfo
    async def member_roles(self, member_id: str | None = None, *, include_groups: bool = True) -> list[MemberRole]
    async def members(self) -> list[AppMember]
    async def operation(self, name: Literal['describe_schema', 'preview_schema_changes', 'apply_schema_changes', 'list_code_pages', 'read_code_page', 'preview_code_page_change', 'apply_code_page_change'], *, max_changes: int = 20) -> 'AsyncAppOperation'
    async def preview_schema_changes(self, changes: Sequence[CreateTable | UpdateTable | DeleteTable | CreateField | UpdateField | DeleteField | SetKeyField | 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]
    async def triggers(self) -> list[AppTrigger]
    async def update_role_assignments(self, changes: Sequence[RoleAssignmentUpdate]) -> RoleAssignmentResult
    def url(self) -> str
class AsyncAppOperation(object)
    def __init__(self, app: AsyncApp, name: Literal['describe_schema', 'preview_schema_changes', 'apply_schema_changes', 'list_code_pages', 'read_code_page', 'preview_code_page_change', 'apply_code_page_change'], input_schema: dict[str, Any], max_changes: int = 20) -> None
    property input_schema -> dict[str, Any]
    property name -> Literal['describe_schema', 'preview_schema_changes', 'apply_schema_changes', 'list_code_pages', 'read_code_page', 'preview_code_page_change', 'apply_code_page_change']
    async def run(self, arguments: Mapping[str, Any]) -> Any
class AsyncCodePage(object)
    def __init__(self, transport: AsyncTransport, app_id: str, ref: str | int) -> None
    async def preview_change(self, text: str) -> CodePagePreview
    async def read(self) -> CodePageContent
    def url(self) -> str
    async def write(self, text: str, *, expected_sha256: str | None = None) -> CodePageWriteResult
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, metadata_cache_seconds: 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
    async def apps(self, *, admin_only: bool = False) -> list[AppListing]
    def clear_metadata_cache(self) -> None
    async def create_app(self, name: str, *, description: str | None = None, assign_token: bool = True) -> AsyncApp
    async def current_user(self) -> UserAccount
    async def find_user(self, email: str) -> UserAccount
    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, metadata_cache_seconds: 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) -> RecordPage
    async def run_summary(self, *, page_size: int = 1000, max_total: int | None = None) -> list[dict[str, Any]]
    async def url(self, *, edit: bool = False) -> str
class AsyncTable(object)
    async def compile_where(self, where: WhereExpression | str) -> str
    async def count(self, where: WhereExpression | 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: WhereExpression | 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: WhereExpression | 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: WhereExpression | str | None = None) -> Field
    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: WhereExpression | 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: WhereExpression | None = None, require_preview: bool = False, max_default_fields: int | None = None) -> 'AsyncTableOperation'
    async def preview_delete(self, where: WhereExpression | 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: WhereExpression | 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: WhereExpression | 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) -> RecordPage
    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, time_zone: 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: WhereExpression | 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 triggers(self) -> list[AppTrigger]
    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 AsyncTableOperation(object)
    def __init__(self, table: AsyncTable, spec: OperationSpec) -> None
    property input_schema -> dict[str, Any]
    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: WhereExpression | None = None) -> Any
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, quickbase_code: int | None = None) -> None
    property doc_url -> str
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, quickbase_code: int | None = None) -> None
    property doc_url -> str
class BoundPolicy(object)
    def __eq__(self, other: object) -> bool
    def __init__(self) -> None
    def allows(self, verb: Literal['read', 'filter', 'sort', 'insert', 'update', 'delete', 'download', 'delete_file', 'report', 'run_formula', 'create_field', 'update_field', 'delete_field', 'formula', 'lookup', 'summary', 'link', 'unlink', 'update_table', 'delete_table', 'set_key_field', 'create_tables', 'read_code_pages', 'write_code_pages'], table: str, *, field: str | int | None = None, fields: Sequence[str | int] = (), source: tuple[str, str | int] | None = None) -> PolicyDecision
    field app_id: str | None
    property created -> tuple[str, ...]
    def decide(self, request: ReadRequest | WriteRequest) -> PolicyDecision
    def explain(self, verb: Literal['read', 'filter', 'sort', 'insert', 'update', 'delete', 'download', 'delete_file', 'report', 'run_formula', 'create_field', 'update_field', 'delete_field', 'formula', 'lookup', 'summary', 'link', 'unlink', 'update_table', 'delete_table', 'set_key_field', 'create_tables', 'read_code_pages', 'write_code_pages'], table: str, *, field: str | int | None = None, fields: Sequence[str | int] = (), source: tuple[str, str | int] | None = None) -> str
    classmethod def from_json(cls, text: str, *, rules: Sequence[CustomRule] = ()) -> 'BoundPolicy'
    property hash -> str
    def max_records(self, table_id: str) -> int | None
    def offers(self, table: str) -> PolicyOffers[NamedItem]
    def row_limit(self, table_id: str) -> str | None
    def tags_of(self, table_id: str, field_id: int) -> frozenset[str]
    def to_json(self) -> str
value ChangeRisk = Literal['additive', 'modifying', 'destructive']
class CodePage(object)
    def __init__(self, transport: Transport, app_id: str, ref: str | int) -> None
    def preview_change(self, text: str) -> CodePagePreview
    def read(self) -> CodePageContent
    def url(self) -> str
    def write(self, text: str, *, expected_sha256: str | None = None) -> CodePageWriteResult
class CodePageChangedError(QuickbaseError)
    def __init__(self, *args: object) -> None
    property doc_url -> str
class CodePageContent(object)
    def __eq__(self, other)
    def __init__(self, *, id: int | None, name: str | None, text: str, sha256: str) -> None
    field id: int | None
    field name: str | None
    field sha256: str
    field text: str
class CodePageInfo(object)
    def __eq__(self, other)
    def __init__(self, *, id: int, name: str, type: str) -> None
    field id: int
    field name: str
    field type: str
class CodePagePreview(object)
    def __eq__(self, other)
    def __init__(self, *, code_page: str | int, current: CodePageContent | None, proposed_sha256: str, diff: str, unchanged: bool, confirmation: str = '') -> None
    field code_page: str | int
    field confirmation: str
    field current: CodePageContent | None
    field diff: str
    field proposed_sha256: str
    field unchanged: bool
class CodePageWriteResult(object)
    def __eq__(self, other)
    def __init__(self, *, content: CodePageContent, previous: CodePageContent | None, created: bool) -> None
    field content: CodePageContent
    field created: bool
    field previous: CodePageContent | None
value ColumnMap = Mapping[str, str | int | None]
class ConfigurationError(QuickbaseError, ValueError)
    def __init__(self, *args: object) -> None
    property doc_url -> str
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 CustomRule(Protocol)
    def __init__(self, *args, **kwargs)
    def decide(self, request: 'ReadRequest | WriteRequest') -> PolicyDecision | None
value DecisionLayer = Literal['policy', 'rows', 'derived']
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(RecordPage)
    def __eq__(self, other)
    def __init__(self, *, records: tuple[Record, ...], total: int, skip: int, columns: tuple[str, ...] = (), triggers: tuple[AppTrigger, ...] | None = None) -> 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
    field triggers: tuple[AppTrigger, ...] | None
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 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]) -> WhereExpression
    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
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', 'tagged', 'labeled_like', 'named'], values: tuple[str | int, ...] = ()) -> None
    field kind: Literal['all', 'new', 'tagged', '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 FileRowFailure(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, ...] = (), failed_rows: tuple[FileRowFailure, ...] = ()) -> None
    def __iter__(self) -> Iterator[Mapping[str, Any]]
    def __len__(self) -> int
    field columns: Mapping[str, str]
    field failed_rows: tuple[FileRowFailure, ...]
    property ok -> bool
    def raise_for_failures(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
    property doc_url -> str
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_at: datetime.datetime | None, creator: User | None) -> None
    field creator: User | None
    field file_name: str
    field number: int
    field uploaded_at: 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 InvalidConfirmationError(QuickbaseError)
    def __init__(self, *args: object) -> None
    property doc_url -> str
class InvalidQueryError(QuickbaseError, ValueError)
    def __init__(self, *args: object) -> None
    property doc_url -> str
class InvalidResponseError(QuickbaseError)
    def __init__(self, *args: object) -> None
    property doc_url -> str
class InvalidValueError(QuickbaseError, ValueError)
    def __init__(self, *args: object) -> None
    property doc_url -> str
class MemberRole(object)
    def __eq__(self, other)
    def __init__(self, *, role: Role, assigned_through: str | None) -> None
    field assigned_through: str | None
    field role: Role
class NamedItem(object)
    def __eq__(self, other)
    def __init__(self, id: str | int, name: str) -> None
    field id: str | int
    field name: str
class NetworkError(QuickbaseError)
    def __init__(self, *args: object) -> None
    property doc_url -> str
class NoLongerAvailableError(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, quickbase_code: int | None = None) -> None
    property doc_url -> str
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, quickbase_code: int | None = None) -> None
    property doc_url -> str
class Period(object)
    def __eq__(self, other)
    def __init__(self, field: str | int | F, unit: Literal['day', 'week', 'month', 'quarter', 'year'], time_zone: datetime.tzinfo = datetime.timezone.utc) -> None
    field field: str | int | F
    field time_zone: 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, quickbase_code: int | None = None) -> None
    property doc_url -> str
class PlannedChange(object)
    def __eq__(self, other)
    def __init__(self, *, change: CreateTable | UpdateTable | DeleteTable | CreateField | UpdateField | DeleteField | SetKeyField | CreateRelationship | CreateLookupField | CreateSummaryField | DeleteRelationship, status: Literal['ready', 'already_done', 'blocked'], risk: Literal['additive', 'modifying', 'destructive'], description: str, settings: Mapping[str, ValueChange] = <factory>, warnings: tuple[str, ...] = (), blockers: tuple[str, ...] = (), affected_records: int | None = None, url: 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 | SetKeyField | CreateRelationship | CreateLookupField | CreateSummaryField | DeleteRelationship
    field description: str
    field policy_effects: tuple[str, ...]
    field risk: Literal['additive', 'modifying', 'destructive']
    field settings: Mapping[str, ValueChange]
    field status: Literal['ready', 'already_done', 'blocked']
    field url: str | None
    field warnings: tuple[str, ...]
class Policy(object)
    def __init__(self, *, app: str | None = None, tags: Mapping[str, Sequence[str | tuple[str, str | int] | FieldSelector]] | None = None, rules: Sequence[PolicyRule | CustomRule] = (), 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 PolicyDecision(object)
    def __bool__(self) -> bool
    def __eq__(self, other)
    def __init__(self, *, allowed: bool, verb: Literal['read', 'filter', 'sort', 'insert', 'update', 'delete', 'download', 'delete_file', 'report', 'run_formula', 'create_field', 'update_field', 'delete_field', 'formula', 'lookup', 'summary', 'link', 'unlink', 'update_table', 'delete_table', 'set_key_field', 'create_tables', 'read_code_pages', 'write_code_pages'], layer: Literal['policy', 'rows', 'derived'] = 'policy', rule: str | None = None, reason: str = '', hint: str | None = None, table: NamedItem | None = None, fields: tuple[NamedItem, ...] = ()) -> None
    field allowed: bool
    field fields: tuple[NamedItem, ...]
    field hint: str | None
    field layer: Literal['policy', 'rows', 'derived']
    def message(self) -> str
    field reason: str
    field rule: str | None
    field table: NamedItem | None
    field verb: Literal['read', 'filter', 'sort', 'insert', 'update', 'delete', 'download', 'delete_file', 'report', 'run_formula', 'create_field', 'update_field', 'delete_field', 'formula', 'lookup', 'summary', 'link', 'unlink', 'update_table', 'delete_table', 'set_key_field', 'create_tables', 'read_code_pages', 'write_code_pages']
    property what -> str
class PolicyOffers(Generic)
    def __eq__(self, other)
    def __init__(self, *, table: NamedItem, 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_verbs: 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, can_read_code_pages: bool = False, can_write_code_pages: bool = False) -> None
    field can_delete: bool
    field can_read_code_pages: bool
    field can_write_code_pages: 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_verbs: frozenset[str]
    field sortable: tuple[~T, ...]
    field table: NamedItem
    field updatable: tuple[~T, ...]
    field user_emails: bool
class PolicyRefusedError(QuickbaseError)
    def __init__(self, decision: Any) -> None
    property doc_url -> str
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
value PolicySchemaVerb = Literal['create_field', 'update_field', 'delete_field', 'formula', 'lookup', 'summary', 'link', 'unlink', 'update_table', 'delete_table', 'set_key_field']
value PolicyVerb = Literal['read', 'filter', 'sort', 'insert', 'update', 'delete', 'download', 'delete_file', 'report', 'run_formula', 'create_field', 'update_field', 'delete_field', 'formula', 'lookup', 'summary', 'link', 'unlink', 'update_table', 'delete_table', 'set_key_field', 'create_tables', 'read_code_pages', 'write_code_pages']
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, metadata_cache_seconds: float = 300.0, policy: Policy | BoundPolicy | None = None, confirmation_key: bytes | None = None) -> None
    def app(self, app_id: str) -> App
    def apps(self, *, admin_only: bool = False) -> list[AppListing]
    def clear_metadata_cache(self) -> None
    def close(self) -> None
    def create_app(self, name: str, *, description: str | None = None, assign_token: bool = True) -> App
    def current_user(self) -> UserAccount
    def find_user(self, email: str) -> UserAccount
    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, metadata_cache_seconds: 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)
    def __init__(self, *args: object) -> None
    property doc_url -> str
class RateLimitError(APIError)
    def __init__(self, summary: str, *, retry_after: float | None = None, **kwargs: object) -> None
    property doc_url -> str
value ReadAction = Literal['query', 'summarize', 'delete', 'report', 'summary_report', 'file', 'formula', 'tables', 'fields', 'relationships', 'reports', 'app', 'roles', 'field_usage', 'app_triggers', 'apps', 'current_user', 'find_user', 'members', 'member_roles', 'code_pages', '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_triggers', 'apps', 'current_user', 'find_user', 'members', 'member_roles', 'code_pages', '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, app_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_triggers', 'apps', 'current_user', 'find_user', 'members', 'member_roles', 'code_pages', 'other']
    field app_id: str | None
    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, ValueChange]) -> None
    field fields: Mapping[str, ValueChange]
    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 RecordPage(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 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, ...] = (), cross_app: bool, raw: Mapping[str, Any]) -> None
    field child_table_id: str
    field cross_app: bool
    field foreign_key_field_id: int | None
    field id: int
    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) -> RecordPage
    def run_summary(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)
    def __init__(self, *args: object) -> None
    property doc_url -> str
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
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 RoleAssignment(object)
    def __eq__(self, other)
    def __init__(self, member_id: str, role_id: int, kind: Literal['user', 'group'] = 'user') -> None
    field kind: Literal['user', 'group']
    field member_id: str
    field role_id: int
class RoleAssignmentFailure(object)
    def __eq__(self, other)
    def __init__(self, *, change: RoleAssignment | RoleAssignmentUpdate, error: str) -> None
    field change: RoleAssignment | RoleAssignmentUpdate
    field error: str
class RoleAssignmentResult(object)
    def __eq__(self, other)
    def __init__(self, *, changed: tuple[RoleAssignment | RoleAssignmentUpdate, ...] = (), failed: tuple[RoleAssignmentFailure, ...] = ()) -> None
    field changed: tuple[RoleAssignment | RoleAssignmentUpdate, ...]
    field failed: tuple[RoleAssignmentFailure, ...]
class RoleAssignmentUpdate(object)
    def __eq__(self, other)
    def __init__(self, member_id: str, from_role_id: int, to_role_id: int, kind: Literal['user', 'group'] = 'user') -> None
    field from_role_id: int
    field kind: Literal['user', 'group']
    field member_id: str
    field to_role_id: int
value SchemaChange = CreateTable | UpdateTable | DeleteTable | CreateField | UpdateField | DeleteField | SetKeyField | CreateRelationship | CreateLookupField | CreateSummaryField | DeleteRelationship
value SchemaChangeAction = Literal['create_table', 'update_table', 'delete_table', 'create_field', 'update_field', 'delete_field', 'set_key_field', 'create_relationship', 'create_lookup_field', 'create_summary_field', 'delete_relationship']
class SchemaChangeError(WriteError)
    def __init__(self, summary: str, *, result: Any = None) -> None
    property doc_url -> str
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)
    def __init__(self, *args: object) -> None
    property doc_url -> str
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, ...]
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, quickbase_code: int | None = None) -> None
    property doc_url -> str
class SetKeyField(object)
    def __eq__(self, other)
    def __init__(self, *, table: str, field: str | int) -> None
    field field: str | int
    field table: str
value StatisticName = Literal['sum', 'avg', 'median', 'std_dev', 'min', 'max', 'distinct_count']
value SummaryFieldFunction = 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 SummaryTooLargeError(InvalidQueryError)
    def __init__(self, matched: int, limit: int) -> None
    property doc_url -> str
class Table(object)
    def compile_where(self, where: WhereExpression | str) -> str
    def count(self, where: WhereExpression | 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: WhereExpression | 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: WhereExpression | 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: WhereExpression | str | None = None) -> Field
    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: WhereExpression | 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: WhereExpression | None = None, require_preview: bool = False, max_default_fields: int | None = None) -> 'TableOperation'
    def preview_delete(self, where: WhereExpression | 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: WhereExpression | 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: WhereExpression | 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) -> RecordPage
    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, time_zone: 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: WhereExpression | 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 triggers(self) -> list[AppTrigger]
    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 TableOperation(object)
    def __init__(self, table: Table, spec: OperationSpec) -> None
    property input_schema -> dict[str, Any]
    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: WhereExpression | None = None) -> Any
value TableOperationName = Literal['query', 'count', 'summarize', 'insert', 'update', 'delete', 'preview_update', 'preview_delete', 'run_report', 'run_summary_report', 'run_formula', 'download_file', 'delete_file_version']
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, ...]
value ToolErrorCode = Literal['misconfigured', 'needs_confirmation', 'invalid_arguments', 'summary_too_large', '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', 'no_longer_available', 'code_page_changed', 'timeout', 'network_error', 'invalid_response', 'quickbase_error', 'internal']
class UnknownFieldError(QuickbaseError, LookupError)
    def __init__(self, *args: object) -> None
    property doc_url -> str
class UnknownReportError(QuickbaseError, LookupError)
    def __init__(self, *args: object) -> None
    property doc_url -> str
class UnknownTableError(QuickbaseError, LookupError)
    def __init__(self, *args: object) -> None
    property doc_url -> str
class UnsupportedReportError(QuickbaseError)
    def __init__(self, *args: object) -> None
    property doc_url -> str
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, ...] = (), triggers: tuple[AppTrigger, ...] | None = None) -> None
    field changes: tuple[RecordChange, ...]
    field missing_ids: tuple[int, ...]
    field triggers: tuple[AppTrigger, ...] | None
    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
class UserAccount(object)
    def __eq__(self, other)
    def __init__(self, *, id: str, email: str | None, first_name: str | None, last_name: str | None, screen_name: str | None) -> None
    field email: str | None
    field first_name: str | None
    field id: str
    field last_name: str | None
    field screen_name: str | None
class ValueChange(object)
    def __eq__(self, other)
    def __init__(self, before: Any, after: Any) -> None
    field after: Any
    field before: Any
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
class WhereExpression(object)
    def __and__(self, other: 'WhereExpression') -> 'Group'
    def __bool__(self) -> bool
    def __or__(self, other: 'WhereExpression') -> 'Group'
    def compile(self, fields: FieldIndex) -> str
value WriteAction = Literal['insert', 'update', 'upsert', 'delete', 'delete_file', 'create_table', 'update_table', 'delete_table', 'create_field', 'update_field', 'delete_field', 'create_relationship', 'create_lookup_field', 'create_summary_field', 'update_relationship', 'delete_relationship', 'create_app', 'copy_app', 'delete_app', 'write_code_page', 'write_role_assignments', 'set_key_field', 'other']
class WriteError(QuickbaseError)
    def __init__(self, summary: str, *, result: Any = None) -> None
    property doc_url -> str
class WritePermissionDeniedError(WriteError, PermissionDeniedError)
    def __init__(self, summary: str, *, result: Any = None, status_code: int = 403, **kwargs: Any) -> None
    property doc_url -> str
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', 'create_lookup_field', 'create_summary_field', 'update_relationship', 'delete_relationship', 'create_app', 'copy_app', 'delete_app', 'write_code_page', 'write_role_assignments', 'set_key_field', '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(), allows_html: bool = False) -> None
    field action: Literal['insert', 'update', 'upsert', 'delete', 'delete_file', 'create_table', 'update_table', 'delete_table', 'create_field', 'update_field', 'delete_field', 'create_relationship', 'create_lookup_field', 'create_summary_field', 'update_relationship', 'delete_relationship', 'create_app', 'copy_app', 'delete_app', 'write_code_page', 'write_role_assignments', 'set_key_field', 'other']
    field allows_html: bool
    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, ...] = (), failed_rows: tuple[WriteRowFailure, ...] = (), row_ids: tuple[int | None, ...] = ()) -> None
    field created_ids: tuple[int, ...]
    field failed_rows: tuple[WriteRowFailure, ...]
    field row_ids: tuple[int | None, ...]
    field unchanged_ids: tuple[int, ...]
    field updated_ids: tuple[int, ...]
class WriteRowFailure(object)
    def __eq__(self, other)
    def __init__(self, *, row_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 messages: tuple[str, ...]
    field reason: Literal['duplicate', 'permission', 'invalid_choice', 'rule', 'other']
    field row_index: 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) -> WhereExpression
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]
