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 create_table(self, name: str, *, description: str | None = None, single_record_name: str | None = None, plural_record_name: str | None = None) -> 'Table'
    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 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 typed(self, model: type[~R]) -> 'TypedTable[R]'
    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 AsyncApp(object)
    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 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 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 typed(self, model: type[~R]) -> 'AsyncTypedTable[R]'
    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', '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, read_only: bool = False, write_policy: Callable[[WriteRequest], bool] | None = None, read_policy: Callable[[ReadRequest], bool] | None = None) -> None
    async def aclose(self) -> None
    def app(self, app_id: str) -> AsyncApp
    def clear_schema_cache(self) -> None
    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, read_only: bool = False, write_policy: Callable[[WriteRequest], bool] | None = None, read_policy: Callable[[ReadRequest], bool] | None = None, token_env: str = 'QB_USER_TOKEN') -> Self
    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
class AsyncReport(object)
    async def info(self) -> ReportInfo
    def run(self, *, page_size: int = 1000, limit: int | None = None) -> AsyncRecordIterator
    async def run_page(self, *, top: int = 100, skip: int = 0) -> Page
    async def summary_rows(self, *, page_size: int = 1000, limit: int | None = None) -> list[dict[str, Any]]
    async def url(self, *, edit: bool = False) -> str
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, field_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_label: 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 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) -> Field
    async def ensure_field(self, label: str, field_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_label: str) -> Relationship
    async def ensure_summary_field(self, relationship: Relationship, child_field: str | int, label: str, *, function: str = 'SUM') -> Field
    async def field_url(self, field: str | int) -> str
    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, rows: Iterable[Mapping[str | int, Any]], *, 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', 'summary_report', 'run_formula', 'download_file', 'delete_file_version'], *, fields: Sequence[str | int] | None = None, descriptions: Mapping[str | int, str] | None = None, reports: Sequence[str] | Mapping[str, str] | None = None, formula: str | None = None, max_records: int | None = None, max_rows: int = 100, scope: Expression | None = None, require_preview: bool = False) -> '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, top: int = 100) -> Page
    async def preview_update(self, rows: Iterable[Mapping[str | int, Any]]) -> 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, limit: 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, top: int = 100, skip: int = 0) -> Page
    async def record_url(self, record_id: int, *, edit: bool = False) -> str
    async def record_url_pattern(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 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, total: str | int | F | Sequence[str | int | F] | None = None, average: str | int | F | Sequence[str | int | F] | None = None, minimum: str | int | F | Sequence[str | int | F] | None = None, maximum: str | int | F | Sequence[str | int | F] | None = None, max_records: int | None = None, page_size: int = 1000) -> list[SummaryRow]
    async def update(self, rows: Iterable[Mapping[str | int, Any]], *, 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 upsert(self, rows: Iterable[Mapping[str | int, Any]], *, merge_on: str | int, batch_size: int = 1000, timeout: float | None = None) -> WriteResult
    async def url(self) -> str
class AsyncTypedIterator(Generic)
    def __aiter__(self) -> Self
    async def __anext__(self) -> ~R
class AsyncTypedTable(Generic)
    async def check_schema(self) -> None
    async def count(self, where: Expression | str | None = None) -> int
    async def delete(self, where: Expression | str) -> int
    async def first(self, *, where: Expression | str | None = None, select: TypedField | Sequence[TypedField] | None = None, order_by: TypedField | int | Sequence[TypedField | int] | None = None) -> ~R | None
    async def get(self, record_id: int, *, select: TypedField | Sequence[TypedField] | None = None) -> ~R | None
    async def insert(self, rows: Iterable[Row[~R]], *, batch_size: int = 1000, timeout: float | None = None) -> WriteResult
    async def preview_delete(self, where: Expression | str, *, order_by: TypedField | int | Sequence[TypedField | int] | None = None, top: int = 100) -> TypedPage[~R]
    async def preview_update(self, rows: Iterable[Row[~R]]) -> UpdatePreview
    def query(self, *, where: Expression | str | None = None, select: TypedField | Sequence[TypedField] | None = None, order_by: TypedField | int | Sequence[TypedField | int] | None = None, page_size: int = 1000, limit: int | None = None) -> 'AsyncTypedIterator[R]'
    async def query_page(self, *, where: Expression | str | None = None, select: TypedField | Sequence[TypedField] | None = None, order_by: TypedField | int | Sequence[TypedField | int] | None = None, top: int = 100, skip: int = 0) -> TypedPage[~R]
    async def summarize(self, group_by: str | int | F | Period | Sequence[str | int | F | Period] | None = None, *, where: Expression | str | None = None, total: str | int | F | Sequence[str | int | F] | None = None, average: str | int | F | Sequence[str | int | F] | None = None, minimum: str | int | F | Sequence[str | int | F] | None = None, maximum: str | int | F | Sequence[str | int | F] | None = None, max_records: int | None = None, page_size: int = 1000) -> list[SummaryRow]
    property table -> AsyncTable
    async def update(self, rows: Iterable[Row[~R]], *, batch_size: int = 1000, timeout: float | None = None) -> WriteResult
    async def upsert(self, rows: Iterable[Row[~R]], *, merge_on: TypedField, batch_size: int = 1000, timeout: float | None = None) -> WriteResult
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 Column(object)
    def __eq__(self, other)
    def __init__(self, name: str, id: int, field_type: str, writable: bool, label: str, read_as: str = '') -> None
    field field_type: str
    field id: int
    field label: str
    field name: str
    field read_as: str
    field writable: bool
class ConfigurationError(QuickbaseError, ValueError)
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 is_in(self, values: Iterable[Any]) -> Expression
    def not_contains(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, 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_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 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, *, name: str, data: bytes, content_type: str | None) -> None
    field content_type: str | None
    field data: bytes
    field name: str
class FileUpload(object)
    def __eq__(self, other)
    def __init__(self, name: str, data: bytes) -> None
    field data: bytes
    field 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)
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 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', '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', 'summary_report', 'run_formula', 'download_file', 'delete_file_version']
value OrderBy = TypedField | int | Sequence[TypedField | int] | None
class Page(object)
    def __eq__(self, other)
    def __init__(self, *, records: tuple[Record, ...], total: int, skip: int) -> None
    property has_more -> bool
    property next_skip -> int
    field records: tuple[Record, ...]
    field skip: int
    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']
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 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, read_only: bool = False, write_policy: Callable[[WriteRequest], bool] | None = None, read_policy: Callable[[ReadRequest], bool] | None = None) -> None
    def app(self, app_id: str) -> App
    def clear_schema_cache(self) -> None
    def close(self) -> None
    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, read_only: bool = False, write_policy: Callable[[WriteRequest], bool] | None = None, read_policy: Callable[[ReadRequest], bool] | None = None, token_env: str = 'QB_USER_TOKEN') -> Self
    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
class ReadAccess(object)
    def __eq__(self, other)
    def __init__(self, *, fields: bool | Collection[int], filter: bool | Collection[int] | None = None, sort: bool | Collection[int] | None = None, write_only: Collection[int] = (), files: Collection[int] = (), reports: Collection[str | int] = (), summary_reports: Collection[str | int] = (), max_records: int = 100, max_summary_records: int = 10000, user_emails: bool = False) -> None
    field fields: bool | frozenset[int]
    field files: frozenset[int]
    field filter: bool | frozenset[int]
    field max_records: int
    field max_summary_records: int
    field reports: frozenset[str]
    field sort: bool | frozenset[int]
    field summary_reports: frozenset[str]
    field user_emails: bool
    field write_only: frozenset[int]
value ReadAction = Literal['query', 'summarize', 'delete', 'report', 'summary_report', 'file', 'formula', 'tables', 'fields', 'relationships', 'reports', 'app', 'roles', 'other']
value ReadPolicy = Callable[[ReadRequest], bool]
class ReadRefusedError(RequestRefusedError)
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', '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, top: 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', 'other']
    field field_ids: frozenset[int] | None
    field filter_field_ids: frozenset[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
    field top: int | None
class ReadRules(object)
    def __call__(self, request: ReadRequest) -> bool
    def __init__(self, tables: Mapping[str, ReadAccess]) -> 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
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, limit: int | None = None) -> RecordIterator
    def run_page(self, *, top: int = 100, skip: int = 0) -> Page
    def summary_rows(self, *, page_size: int = 1000, limit: 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 RequestRefusedError(QuickbaseError)
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
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 Row(dict, Generic)
    def __init__(self, values: Mapping[int, Any] | None = None, *, table_id: str | None = None) -> None
class RowError(object)
    def __eq__(self, other)
    def __init__(self, *, index: int, messages: tuple[str, ...], kind: Literal['duplicate', 'permission', 'invalid_choice', 'rule', 'other'] = 'other', field_id: int | None = None) -> None
    field field_id: int | None
    field index: int
    field kind: Literal['duplicate', 'permission', 'invalid_choice', 'rule', 'other']
    field messages: tuple[str, ...]
class SchemaMismatchError(QuickbaseError)
value Select = TypedField | Sequence[TypedField] | None
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
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, total: Mapping[str, float] = <factory>, average: Mapping[str, float | None] = <factory>, minimum: Mapping[str, Any] = <factory>, maximum: Mapping[str, Any] = <factory>) -> None
    field average: Mapping[str, float | None]
    field count: int
    field group: Mapping[str, Any]
    field maximum: Mapping[str, Any]
    field minimum: Mapping[str, Any]
    field total: 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, field_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_label: 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 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) -> Field
    def ensure_field(self, label: str, field_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_label: str) -> Relationship
    def ensure_summary_field(self, relationship: Relationship, child_field: str | int, label: str, *, function: str = 'SUM') -> Field
    def field_url(self, field: str | int) -> str
    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, rows: Iterable[Mapping[str | int, Any]], *, 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', 'summary_report', 'run_formula', 'download_file', 'delete_file_version'], *, fields: Sequence[str | int] | None = None, descriptions: Mapping[str | int, str] | None = None, reports: Sequence[str] | Mapping[str, str] | None = None, formula: str | None = None, max_records: int | None = None, max_rows: int = 100, scope: Expression | None = None, require_preview: bool = False) -> '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, top: int = 100) -> Page
    def preview_update(self, rows: Iterable[Mapping[str | int, Any]]) -> 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, limit: 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, top: int = 100, skip: int = 0) -> Page
    def record_url(self, record_id: int, *, edit: bool = False) -> str
    def record_url_pattern(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 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, total: str | int | F | Sequence[str | int | F] | None = None, average: str | int | F | Sequence[str | int | F] | None = None, minimum: str | int | F | Sequence[str | int | F] | None = None, maximum: str | int | F | Sequence[str | int | F] | None = None, max_records: int | None = None, page_size: int = 1000) -> list[SummaryRow]
    def update(self, rows: Iterable[Mapping[str | int, Any]], *, 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 upsert(self, rows: Iterable[Mapping[str | int, Any]], *, 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]
value ToolErrorCode = Literal['configuration', 'invalid_query', 'invalid_value', 'read_refused', 'write_refused', 'refused', 'unknown_table', 'unknown_field', 'unknown_report', 'unsupported_report', 'schema_mismatch', 'partial_write', 'write_failed', 'write_permission', 'authentication', 'permission_denied', 'not_found', 'bad_request', 'rate_limited', 'server_error', 'api_error', 'timeout', 'network', 'invalid_response', 'error', 'internal']
class TypedField(F)
    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
    property desc -> int
    property id -> int
    def is_in(self, values: Iterable[Any]) -> Expression
    def not_contains(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 TypedIterator(Generic)
    def __iter__(self) -> Self
    def __next__(self) -> ~R
class TypedPage(Generic)
    def __eq__(self, other)
    def __init__(self, *, records: tuple[~R, ...], total: int, skip: int) -> None
    property has_more -> bool
    property next_skip -> int
    field records: tuple[~R, ...]
    field skip: int
    field total: int
class TypedRecord(object)
    classmethod def from_record(cls, record: Record, *, only: Collection[int] | None = None) -> Self
class TypedTable(Generic)
    def check_schema(self) -> None
    def count(self, where: Expression | str | None = None) -> int
    def delete(self, where: Expression | str) -> int
    def first(self, *, where: Expression | str | None = None, select: TypedField | Sequence[TypedField] | None = None, order_by: TypedField | int | Sequence[TypedField | int] | None = None) -> ~R | None
    def get(self, record_id: int, *, select: TypedField | Sequence[TypedField] | None = None) -> ~R | None
    def insert(self, rows: Iterable[Row[~R]], *, batch_size: int = 1000, timeout: float | None = None) -> WriteResult
    def preview_delete(self, where: Expression | str, *, order_by: TypedField | int | Sequence[TypedField | int] | None = None, top: int = 100) -> TypedPage[~R]
    def preview_update(self, rows: Iterable[Row[~R]]) -> UpdatePreview
    def query(self, *, where: Expression | str | None = None, select: TypedField | Sequence[TypedField] | None = None, order_by: TypedField | int | Sequence[TypedField | int] | None = None, page_size: int = 1000, limit: int | None = None) -> 'TypedIterator[R]'
    def query_page(self, *, where: Expression | str | None = None, select: TypedField | Sequence[TypedField] | None = None, order_by: TypedField | int | Sequence[TypedField | int] | None = None, top: int = 100, skip: int = 0) -> TypedPage[~R]
    def summarize(self, group_by: str | int | F | Period | Sequence[str | int | F | Period] | None = None, *, where: Expression | str | None = None, total: str | int | F | Sequence[str | int | F] | None = None, average: str | int | F | Sequence[str | int | F] | None = None, minimum: str | int | F | Sequence[str | int | F] | None = None, maximum: str | int | F | Sequence[str | int | F] | None = None, max_records: int | None = None, page_size: int = 1000) -> list[SummaryRow]
    property table -> Table
    def update(self, rows: Iterable[Row[~R]], *, batch_size: int = 1000, timeout: float | None = None) -> WriteResult
    def upsert(self, rows: Iterable[Row[~R]], *, merge_on: TypedField, batch_size: int = 1000, timeout: float | None = None) -> WriteResult
value UNSET = UNSET
class UnknownFieldError(QuickbaseError, LookupError)
class UnknownReportError(QuickbaseError, LookupError)
class UnknownTableError(QuickbaseError, LookupError)
class Unset(object)
class UnsupportedReportError(QuickbaseError)
class UpdatePreview(object)
    def __eq__(self, other)
    def __init__(self, *, changes: tuple[RecordChange, ...] = (), unchanged_ids: tuple[int, ...] = (), missing_ids: tuple[int, ...] = ()) -> None
    field changes: tuple[RecordChange, ...]
    field missing_ids: tuple[int, ...]
    field unchanged_ids: tuple[int, ...]
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 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 WriteAccess(object)
    def __eq__(self, other)
    def __init__(self, *, insert: bool | Collection[int] = False, update: bool | Collection[int] = False, delete: bool = False, delete_files: bool = False) -> None
    field delete: bool
    field delete_files: bool
    field insert: bool | frozenset[int]
    field update: bool | frozenset[int]
value WriteAction = Literal['insert', 'update', 'upsert', 'delete', 'delete_file', '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
value WritePolicy = Callable[[WriteRequest], bool]
class WriteRefusedError(RequestRefusedError)
class WriteRequest(object)
    def __eq__(self, other)
    def __init__(self, *, action: Literal['insert', 'update', 'upsert', 'delete', 'delete_file', 'other'], table_id: str | None, field_ids: frozenset[int] | None, row_count: int | None, method: str, path: str) -> None
    field action: Literal['insert', 'update', 'upsert', 'delete', 'delete_file', 'other']
    field field_ids: frozenset[int] | None
    field method: str
    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, ...]
class WriteRules(object)
    def __call__(self, request: WriteRequest) -> bool
    def __init__(self, tables: Mapping[str, WriteAccess]) -> None
def all_of(*policies: Any) -> Any
def parse_where(where: str, fields: Iterable[Field]) -> list[WhereCondition]
def tool_error(error: BaseException) -> dict[str, Any]
def tool_result(value: Any, *, compact: bool = False, max_records: int | None = None, max_text: 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, descriptions: Mapping[str | int, str] | None = None, max_depth: int = 2) -> dict[str, Any]
command pyquickbase codegen
    --app (StoreAction, required)
    --output (StoreAction, required)
    --table (AppendAction, default [])
    --token-env (StoreAction, default 'QB_USER_TOKEN')
    --include-links (StoreTrueAction, default False)
    --check (StoreTrueAction, default False)
