antfly-sdk 0.0.2.dev2__py3-none-any.whl

antfly/client_generated/models/conjunction_query.py

@@ -0,0 +1,492 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.bool_field_query import BoolFieldQuery
+    from ..models.boolean_query import BooleanQuery
+    from ..models.date_range_string_query import DateRangeStringQuery
+    from ..models.disjunction_query import DisjunctionQuery
+    from ..models.doc_id_query import DocIdQuery
+    from ..models.fuzzy_query import FuzzyQuery
+    from ..models.geo_bounding_box_query import GeoBoundingBoxQuery
+    from ..models.geo_bounding_polygon_query import GeoBoundingPolygonQuery
+    from ..models.geo_distance_query import GeoDistanceQuery
+    from ..models.geo_shape_query import GeoShapeQuery
+    from ..models.ip_range_query import IPRangeQuery
+    from ..models.match_all_query import MatchAllQuery
+    from ..models.match_none_query import MatchNoneQuery
+    from ..models.match_phrase_query import MatchPhraseQuery
+    from ..models.match_query import MatchQuery
+    from ..models.multi_match_query import MultiMatchQuery
+    from ..models.multi_phrase_query import MultiPhraseQuery
+    from ..models.numeric_range_query import NumericRangeQuery
+    from ..models.phrase_query import PhraseQuery
+    from ..models.prefix_query import PrefixQuery
+    from ..models.query_string_query import QueryStringQuery
+    from ..models.regexp_query import RegexpQuery
+    from ..models.term_query import TermQuery
+    from ..models.term_range_query import TermRangeQuery
+    from ..models.wildcard_query import WildcardQuery
+
+
+T = TypeVar("T", bound="ConjunctionQuery")
+
+
+@_attrs_define
+class ConjunctionQuery:
+    """
+    Attributes:
+        conjuncts (list[BooleanQuery | BoolFieldQuery | ConjunctionQuery | DateRangeStringQuery | DisjunctionQuery |
+            DocIdQuery | FuzzyQuery | GeoBoundingBoxQuery | GeoBoundingPolygonQuery | GeoDistanceQuery | GeoShapeQuery |
+            IPRangeQuery | MatchAllQuery | MatchNoneQuery | MatchPhraseQuery | MatchQuery | MultiMatchQuery |
+            MultiPhraseQuery | NumericRangeQuery | PhraseQuery | PrefixQuery | QueryStringQuery | RegexpQuery | TermQuery |
+            TermRangeQuery | WildcardQuery]):
+        boost (float | None | Unset): A floating-point number used to decrease or increase the relevance scores of a
+            query.
+    """
+
+    conjuncts: list[
+        BooleanQuery
+        | BoolFieldQuery
+        | ConjunctionQuery
+        | DateRangeStringQuery
+        | DisjunctionQuery
+        | DocIdQuery
+        | FuzzyQuery
+        | GeoBoundingBoxQuery
+        | GeoBoundingPolygonQuery
+        | GeoDistanceQuery
+        | GeoShapeQuery
+        | IPRangeQuery
+        | MatchAllQuery
+        | MatchNoneQuery
+        | MatchPhraseQuery
+        | MatchQuery
+        | MultiMatchQuery
+        | MultiPhraseQuery
+        | NumericRangeQuery
+        | PhraseQuery
+        | PrefixQuery
+        | QueryStringQuery
+        | RegexpQuery
+        | TermQuery
+        | TermRangeQuery
+        | WildcardQuery
+    ]
+    boost: float | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.bool_field_query import BoolFieldQuery
+        from ..models.boolean_query import BooleanQuery
+        from ..models.date_range_string_query import DateRangeStringQuery
+        from ..models.disjunction_query import DisjunctionQuery
+        from ..models.doc_id_query import DocIdQuery
+        from ..models.fuzzy_query import FuzzyQuery
+        from ..models.geo_bounding_box_query import GeoBoundingBoxQuery
+        from ..models.geo_bounding_polygon_query import GeoBoundingPolygonQuery
+        from ..models.geo_distance_query import GeoDistanceQuery
+        from ..models.ip_range_query import IPRangeQuery
+        from ..models.match_all_query import MatchAllQuery
+        from ..models.match_none_query import MatchNoneQuery
+        from ..models.match_phrase_query import MatchPhraseQuery
+        from ..models.match_query import MatchQuery
+        from ..models.multi_match_query import MultiMatchQuery
+        from ..models.multi_phrase_query import MultiPhraseQuery
+        from ..models.numeric_range_query import NumericRangeQuery
+        from ..models.phrase_query import PhraseQuery
+        from ..models.prefix_query import PrefixQuery
+        from ..models.query_string_query import QueryStringQuery
+        from ..models.regexp_query import RegexpQuery
+        from ..models.term_query import TermQuery
+        from ..models.term_range_query import TermRangeQuery
+        from ..models.wildcard_query import WildcardQuery
+
+        conjuncts = []
+        for conjuncts_item_data in self.conjuncts:
+            conjuncts_item: dict[str, Any]
+            if isinstance(conjuncts_item_data, TermQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, MatchQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, MultiMatchQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, MatchPhraseQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, PhraseQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, MultiPhraseQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, FuzzyQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, PrefixQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, RegexpQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, WildcardQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, QueryStringQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, NumericRangeQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, TermRangeQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, DateRangeStringQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, BooleanQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, ConjunctionQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, DisjunctionQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, MatchAllQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, MatchNoneQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, DocIdQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, BoolFieldQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, IPRangeQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, GeoBoundingBoxQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, GeoDistanceQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            elif isinstance(conjuncts_item_data, GeoBoundingPolygonQuery):
+                conjuncts_item = conjuncts_item_data.to_dict()
+            else:
+                conjuncts_item = conjuncts_item_data.to_dict()
+
+            conjuncts.append(conjuncts_item)
+
+        boost: float | None | Unset
+        if isinstance(self.boost, Unset):
+            boost = UNSET
+        else:
+            boost = self.boost
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "conjuncts": conjuncts,
+            }
+        )
+        if boost is not UNSET:
+            field_dict["boost"] = boost
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.bool_field_query import BoolFieldQuery
+        from ..models.boolean_query import BooleanQuery
+        from ..models.date_range_string_query import DateRangeStringQuery
+        from ..models.disjunction_query import DisjunctionQuery
+        from ..models.doc_id_query import DocIdQuery
+        from ..models.fuzzy_query import FuzzyQuery
+        from ..models.geo_bounding_box_query import GeoBoundingBoxQuery
+        from ..models.geo_bounding_polygon_query import GeoBoundingPolygonQuery
+        from ..models.geo_distance_query import GeoDistanceQuery
+        from ..models.geo_shape_query import GeoShapeQuery
+        from ..models.ip_range_query import IPRangeQuery
+        from ..models.match_all_query import MatchAllQuery
+        from ..models.match_none_query import MatchNoneQuery
+        from ..models.match_phrase_query import MatchPhraseQuery
+        from ..models.match_query import MatchQuery
+        from ..models.multi_match_query import MultiMatchQuery
+        from ..models.multi_phrase_query import MultiPhraseQuery
+        from ..models.numeric_range_query import NumericRangeQuery
+        from ..models.phrase_query import PhraseQuery
+        from ..models.prefix_query import PrefixQuery
+        from ..models.query_string_query import QueryStringQuery
+        from ..models.regexp_query import RegexpQuery
+        from ..models.term_query import TermQuery
+        from ..models.term_range_query import TermRangeQuery
+        from ..models.wildcard_query import WildcardQuery
+
+        d = dict(src_dict)
+        conjuncts = []
+        _conjuncts = d.pop("conjuncts")
+        for conjuncts_item_data in _conjuncts:
+
+            def _parse_conjuncts_item(
+                data: object,
+            ) -> (
+                BooleanQuery
+                | BoolFieldQuery
+                | ConjunctionQuery
+                | DateRangeStringQuery
+                | DisjunctionQuery
+                | DocIdQuery
+                | FuzzyQuery
+                | GeoBoundingBoxQuery
+                | GeoBoundingPolygonQuery
+                | GeoDistanceQuery
+                | GeoShapeQuery
+                | IPRangeQuery
+                | MatchAllQuery
+                | MatchNoneQuery
+                | MatchPhraseQuery
+                | MatchQuery
+                | MultiMatchQuery
+                | MultiPhraseQuery
+                | NumericRangeQuery
+                | PhraseQuery
+                | PrefixQuery
+                | QueryStringQuery
+                | RegexpQuery
+                | TermQuery
+                | TermRangeQuery
+                | WildcardQuery
+            ):
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_0 = TermQuery.from_dict(data)
+
+                    return componentsschemas_query_type_0
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_1 = MatchQuery.from_dict(data)
+
+                    return componentsschemas_query_type_1
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_2 = MultiMatchQuery.from_dict(data)
+
+                    return componentsschemas_query_type_2
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_3 = MatchPhraseQuery.from_dict(data)
+
+                    return componentsschemas_query_type_3
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_4 = PhraseQuery.from_dict(data)
+
+                    return componentsschemas_query_type_4
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_5 = MultiPhraseQuery.from_dict(data)
+
+                    return componentsschemas_query_type_5
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_6 = FuzzyQuery.from_dict(data)
+
+                    return componentsschemas_query_type_6
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_7 = PrefixQuery.from_dict(data)
+
+                    return componentsschemas_query_type_7
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_8 = RegexpQuery.from_dict(data)
+
+                    return componentsschemas_query_type_8
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_9 = WildcardQuery.from_dict(data)
+
+                    return componentsschemas_query_type_9
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_10 = QueryStringQuery.from_dict(data)
+
+                    return componentsschemas_query_type_10
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_11 = NumericRangeQuery.from_dict(data)
+
+                    return componentsschemas_query_type_11
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_12 = TermRangeQuery.from_dict(data)
+
+                    return componentsschemas_query_type_12
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_13 = DateRangeStringQuery.from_dict(data)
+
+                    return componentsschemas_query_type_13
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_14 = BooleanQuery.from_dict(data)
+
+                    return componentsschemas_query_type_14
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_15 = ConjunctionQuery.from_dict(data)
+
+                    return componentsschemas_query_type_15
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_16 = DisjunctionQuery.from_dict(data)
+
+                    return componentsschemas_query_type_16
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_17 = MatchAllQuery.from_dict(data)
+
+                    return componentsschemas_query_type_17
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_18 = MatchNoneQuery.from_dict(data)
+
+                    return componentsschemas_query_type_18
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_19 = DocIdQuery.from_dict(data)
+
+                    return componentsschemas_query_type_19
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_20 = BoolFieldQuery.from_dict(data)
+
+                    return componentsschemas_query_type_20
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_21 = IPRangeQuery.from_dict(data)
+
+                    return componentsschemas_query_type_21
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_22 = GeoBoundingBoxQuery.from_dict(data)
+
+                    return componentsschemas_query_type_22
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_23 = GeoDistanceQuery.from_dict(data)
+
+                    return componentsschemas_query_type_23
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_24 = GeoBoundingPolygonQuery.from_dict(data)
+
+                    return componentsschemas_query_type_24
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_query_type_25 = GeoShapeQuery.from_dict(data)
+
+                return componentsschemas_query_type_25
+
+            conjuncts_item = _parse_conjuncts_item(conjuncts_item_data)
+
+            conjuncts.append(conjuncts_item)
+
+        def _parse_boost(data: object) -> float | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(float | None | Unset, data)
+
+        boost = _parse_boost(d.pop("boost", UNSET))
+
+        conjunction_query = cls(
+            conjuncts=conjuncts,
+            boost=boost,
+        )
+
+        conjunction_query.additional_properties = d
+        return conjunction_query
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/create_api_key_request.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.create_api_key_request_row_filter_type_0 import CreateApiKeyRequestRowFilterType0
+    from ..models.permission import Permission
+
+
+T = TypeVar("T", bound="CreateApiKeyRequest")
+
+
+@_attrs_define
+class CreateApiKeyRequest:
+    """Request to create a new API key.
+
+    Attributes:
+        name (str): Human-readable name for the API key. Example: CI pipeline key.
+        expires_in (str | Unset): Duration until expiration (e.g., '720h' for 30 days). Empty means never. Example:
+            720h.
+        permissions (list[Permission] | None | Unset): Optional permission scoping. Each permission must be a subset of
+            the creator's permissions.
+        row_filter (CreateApiKeyRequestRowFilterType0 | None | Unset): Optional per-table row filter. Keys are table
+            names (or '*' for all tables). Values are Antfly query JSON objects. API keys inherit the owner's effective row
+            filters; key-local filters are applied as additional narrowing.
+    """
+
+    name: str
+    expires_in: str | Unset = UNSET
+    permissions: list[Permission] | None | Unset = UNSET
+    row_filter: CreateApiKeyRequestRowFilterType0 | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.create_api_key_request_row_filter_type_0 import CreateApiKeyRequestRowFilterType0
+
+        name = self.name
+
+        expires_in = self.expires_in
+
+        permissions: list[dict[str, Any]] | None | Unset
+        if isinstance(self.permissions, Unset):
+            permissions = UNSET
+        elif isinstance(self.permissions, list):
+            permissions = []
+            for permissions_type_0_item_data in self.permissions:
+                permissions_type_0_item = permissions_type_0_item_data.to_dict()
+                permissions.append(permissions_type_0_item)
+
+        else:
+            permissions = self.permissions
+
+        row_filter: dict[str, Any] | None | Unset
+        if isinstance(self.row_filter, Unset):
+            row_filter = UNSET
+        elif isinstance(self.row_filter, CreateApiKeyRequestRowFilterType0):
+            row_filter = self.row_filter.to_dict()
+        else:
+            row_filter = self.row_filter
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+        if expires_in is not UNSET:
+            field_dict["expires_in"] = expires_in
+        if permissions is not UNSET:
+            field_dict["permissions"] = permissions
+        if row_filter is not UNSET:
+            field_dict["row_filter"] = row_filter
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.create_api_key_request_row_filter_type_0 import CreateApiKeyRequestRowFilterType0
+        from ..models.permission import Permission
+
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        expires_in = d.pop("expires_in", UNSET)
+
+        def _parse_permissions(data: object) -> list[Permission] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                permissions_type_0 = []
+                _permissions_type_0 = data
+                for permissions_type_0_item_data in _permissions_type_0:
+                    permissions_type_0_item = Permission.from_dict(permissions_type_0_item_data)
+
+                    permissions_type_0.append(permissions_type_0_item)
+
+                return permissions_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[Permission] | None | Unset, data)
+
+        permissions = _parse_permissions(d.pop("permissions", UNSET))
+
+        def _parse_row_filter(data: object) -> CreateApiKeyRequestRowFilterType0 | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                row_filter_type_0 = CreateApiKeyRequestRowFilterType0.from_dict(data)
+
+                return row_filter_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(CreateApiKeyRequestRowFilterType0 | None | Unset, data)
+
+        row_filter = _parse_row_filter(d.pop("row_filter", UNSET))
+
+        create_api_key_request = cls(
+            name=name,
+            expires_in=expires_in,
+            permissions=permissions,
+            row_filter=row_filter,
+        )
+
+        create_api_key_request.additional_properties = d
+        return create_api_key_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/create_api_key_request_row_filter_type_0.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="CreateApiKeyRequestRowFilterType0")
+
+
+@_attrs_define
+class CreateApiKeyRequestRowFilterType0:
+    """Optional per-table row filter. Keys are table names (or '*' for all tables). Values are Antfly query JSON objects.
+    API keys inherit the owner's effective row filters; key-local filters are applied as additional narrowing.
+
+    """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        create_api_key_request_row_filter_type_0 = cls()
+
+        create_api_key_request_row_filter_type_0.additional_properties = d
+        return create_api_key_request_row_filter_type_0
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties