publicdotcom-cli 1.0.0__py3-none-any.whl

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_portfolio_gateway_strategy_leg.py

@@ -0,0 +1,78 @@
+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="ComHellopublicUserapigatewayApiRestPortfolioGatewayStrategyLeg")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestPortfolioGatewayStrategyLeg:
+    """Represents a single leg of an option strategy
+
+    Attributes:
+        symbol (str): The symbol of the leg
+        position_type (str): The position type (LONG or SHORT)
+        ratio_quantity (str): The ratio quantity of this leg in the strategy
+    """
+
+    symbol: str
+    position_type: str
+    ratio_quantity: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        symbol = self.symbol
+
+        position_type = self.position_type
+
+        ratio_quantity = self.ratio_quantity
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "symbol": symbol,
+                "positionType": position_type,
+                "ratioQuantity": ratio_quantity,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        symbol = d.pop("symbol")
+
+        position_type = d.pop("positionType")
+
+        ratio_quantity = d.pop("ratioQuantity")
+
+        com_hellopublic_userapigateway_api_rest_portfolio_gateway_strategy_leg = cls(
+            symbol=symbol,
+            position_type=position_type,
+            ratio_quantity=ratio_quantity,
+        )
+
+        com_hellopublic_userapigateway_api_rest_portfolio_gateway_strategy_leg.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_portfolio_gateway_strategy_leg
+
+    @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

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_portfolio_price_type_0.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestPortfolioPriceType0")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestPortfolioPriceType0:
+    """
+    Attributes:
+        last_price (str | Unset):
+        timestamp (datetime.datetime | Unset):
+    """
+
+    last_price: str | Unset = UNSET
+    timestamp: datetime.datetime | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        last_price = self.last_price
+
+        timestamp: str | Unset = UNSET
+        if not isinstance(self.timestamp, Unset):
+            timestamp = self.timestamp.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if last_price is not UNSET:
+            field_dict["lastPrice"] = last_price
+        if timestamp is not UNSET:
+            field_dict["timestamp"] = timestamp
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        last_price = d.pop("lastPrice", UNSET)
+
+        _timestamp = d.pop("timestamp", UNSET)
+        timestamp: datetime.datetime | Unset
+        if isinstance(_timestamp, Unset):
+            timestamp = UNSET
+        else:
+            timestamp = isoparse(_timestamp)
+
+        com_hellopublic_userapigateway_api_rest_portfolio_price_type_0 = cls(
+            last_price=last_price,
+            timestamp=timestamp,
+        )
+
+        com_hellopublic_userapigateway_api_rest_portfolio_price_type_0.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_portfolio_price_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

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_preflight_gateway_margin_impact.py

@@ -0,0 +1,70 @@
+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
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestPreflightGatewayMarginImpact")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestPreflightGatewayMarginImpact:
+    """
+    Attributes:
+        margin_usage_impact (str | Unset):
+        initial_margin_requirement (str | Unset):
+    """
+
+    margin_usage_impact: str | Unset = UNSET
+    initial_margin_requirement: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        margin_usage_impact = self.margin_usage_impact
+
+        initial_margin_requirement = self.initial_margin_requirement
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if margin_usage_impact is not UNSET:
+            field_dict["marginUsageImpact"] = margin_usage_impact
+        if initial_margin_requirement is not UNSET:
+            field_dict["initialMarginRequirement"] = initial_margin_requirement
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        margin_usage_impact = d.pop("marginUsageImpact", UNSET)
+
+        initial_margin_requirement = d.pop("initialMarginRequirement", UNSET)
+
+        com_hellopublic_userapigateway_api_rest_preflight_gateway_margin_impact = cls(
+            margin_usage_impact=margin_usage_impact,
+            initial_margin_requirement=initial_margin_requirement,
+        )
+
+        com_hellopublic_userapigateway_api_rest_preflight_gateway_margin_impact.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_preflight_gateway_margin_impact
+
+    @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

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_preflight_gateway_margin_requirement.py

@@ -0,0 +1,70 @@
+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
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestPreflightGatewayMarginRequirement")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestPreflightGatewayMarginRequirement:
+    """
+    Attributes:
+        long_maintenance_requirement (str | Unset):
+        long_initial_requirement (str | Unset):
+    """
+
+    long_maintenance_requirement: str | Unset = UNSET
+    long_initial_requirement: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        long_maintenance_requirement = self.long_maintenance_requirement
+
+        long_initial_requirement = self.long_initial_requirement
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if long_maintenance_requirement is not UNSET:
+            field_dict["longMaintenanceRequirement"] = long_maintenance_requirement
+        if long_initial_requirement is not UNSET:
+            field_dict["longInitialRequirement"] = long_initial_requirement
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        long_maintenance_requirement = d.pop("longMaintenanceRequirement", UNSET)
+
+        long_initial_requirement = d.pop("longInitialRequirement", UNSET)
+
+        com_hellopublic_userapigateway_api_rest_preflight_gateway_margin_requirement = cls(
+            long_maintenance_requirement=long_maintenance_requirement,
+            long_initial_requirement=long_initial_requirement,
+        )
+
+        com_hellopublic_userapigateway_api_rest_preflight_gateway_margin_requirement.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_preflight_gateway_margin_requirement
+
+    @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

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_preflight_gateway_option_details.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..models.com_hellopublic_userapigateway_api_rest_preflight_gateway_option_details_type import (
+    ComHellopublicUserapigatewayApiRestPreflightGatewayOptionDetailsType,
+)
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestPreflightGatewayOptionDetails")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestPreflightGatewayOptionDetails:
+    """
+    Attributes:
+        base_symbol (str):
+        type_ (ComHellopublicUserapigatewayApiRestPreflightGatewayOptionDetailsType):
+        strike_price (str):
+        option_expire_date (datetime.date):
+    """
+
+    base_symbol: str
+    type_: ComHellopublicUserapigatewayApiRestPreflightGatewayOptionDetailsType
+    strike_price: str
+    option_expire_date: datetime.date
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        base_symbol = self.base_symbol
+
+        type_ = self.type_.value
+
+        strike_price = self.strike_price
+
+        option_expire_date = self.option_expire_date.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "baseSymbol": base_symbol,
+                "type": type_,
+                "strikePrice": strike_price,
+                "optionExpireDate": option_expire_date,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        base_symbol = d.pop("baseSymbol")
+
+        type_ = ComHellopublicUserapigatewayApiRestPreflightGatewayOptionDetailsType(d.pop("type"))
+
+        strike_price = d.pop("strikePrice")
+
+        option_expire_date = isoparse(d.pop("optionExpireDate")).date()
+
+        com_hellopublic_userapigateway_api_rest_preflight_gateway_option_details = cls(
+            base_symbol=base_symbol,
+            type_=type_,
+            strike_price=strike_price,
+            option_expire_date=option_expire_date,
+        )
+
+        com_hellopublic_userapigateway_api_rest_preflight_gateway_option_details.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_preflight_gateway_option_details
+
+    @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

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_preflight_gateway_option_details_type.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class ComHellopublicUserapigatewayApiRestPreflightGatewayOptionDetailsType(str, Enum):
+    CALL = "CALL"
+    PUT = "PUT"
+
+    def __str__(self) -> str:
+        return str(self.value)

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_preflight_gateway_option_rebate.py

@@ -0,0 +1,79 @@
+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
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestPreflightGatewayOptionRebate")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestPreflightGatewayOptionRebate:
+    """
+    Attributes:
+        estimated_option_rebate (str | Unset):
+        option_rebate_percent (int | Unset):
+        per_contract_rebate (str | Unset):
+    """
+
+    estimated_option_rebate: str | Unset = UNSET
+    option_rebate_percent: int | Unset = UNSET
+    per_contract_rebate: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        estimated_option_rebate = self.estimated_option_rebate
+
+        option_rebate_percent = self.option_rebate_percent
+
+        per_contract_rebate = self.per_contract_rebate
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if estimated_option_rebate is not UNSET:
+            field_dict["estimatedOptionRebate"] = estimated_option_rebate
+        if option_rebate_percent is not UNSET:
+            field_dict["optionRebatePercent"] = option_rebate_percent
+        if per_contract_rebate is not UNSET:
+            field_dict["perContractRebate"] = per_contract_rebate
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        estimated_option_rebate = d.pop("estimatedOptionRebate", UNSET)
+
+        option_rebate_percent = d.pop("optionRebatePercent", UNSET)
+
+        per_contract_rebate = d.pop("perContractRebate", UNSET)
+
+        com_hellopublic_userapigateway_api_rest_preflight_gateway_option_rebate = cls(
+            estimated_option_rebate=estimated_option_rebate,
+            option_rebate_percent=option_rebate_percent,
+            per_contract_rebate=per_contract_rebate,
+        )
+
+        com_hellopublic_userapigateway_api_rest_preflight_gateway_option_rebate.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_preflight_gateway_option_rebate
+
+    @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

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_preflight_gateway_price_increment.py

@@ -0,0 +1,80 @@
+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
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestPreflightGatewayPriceIncrement")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestPreflightGatewayPriceIncrement:
+    """Price increment information for option orders.
+
+    Attributes:
+        increment_below_3 (str | Unset):
+        increment_above_3 (str | Unset):
+        current_increment (str | Unset):
+    """
+
+    increment_below_3: str | Unset = UNSET
+    increment_above_3: str | Unset = UNSET
+    current_increment: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        increment_below_3 = self.increment_below_3
+
+        increment_above_3 = self.increment_above_3
+
+        current_increment = self.current_increment
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if increment_below_3 is not UNSET:
+            field_dict["incrementBelow3"] = increment_below_3
+        if increment_above_3 is not UNSET:
+            field_dict["incrementAbove3"] = increment_above_3
+        if current_increment is not UNSET:
+            field_dict["currentIncrement"] = current_increment
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        increment_below_3 = d.pop("incrementBelow3", UNSET)
+
+        increment_above_3 = d.pop("incrementAbove3", UNSET)
+
+        current_increment = d.pop("currentIncrement", UNSET)
+
+        com_hellopublic_userapigateway_api_rest_preflight_gateway_price_increment = cls(
+            increment_below_3=increment_below_3,
+            increment_above_3=increment_above_3,
+            current_increment=current_increment,
+        )
+
+        com_hellopublic_userapigateway_api_rest_preflight_gateway_price_increment.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_preflight_gateway_price_increment
+
+    @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

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_preflight_gateway_regulatory_fees.py

@@ -0,0 +1,118 @@
+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
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestPreflightGatewayRegulatoryFees")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestPreflightGatewayRegulatoryFees:
+    """# GatewayRegulatoryFees
+    Represents various regulatory fees associated with trading orders.
+    <br/>
+    ## Fields
+    - **secFee** - The SEC charges a regulatory fee for sell orders that execute. The fee is based on the dollar amount
+    of the order.
+    - **tafFee** - The Trading Activity Fee is a FINRA fee. The fee is based on the order quantity.
+    - **orfFee** - The Options Regulatory Fee (ORF). This is the combined exchange fee rate for all exchanges. Changes
+    monthly.
+    - **exchangeFee** - The exchange charges a fee for executing orders for index options.
+    - **occFee** - The Options Clearing Corporation Fee (OCC)
+    - **catFee** - The Consolidated Audit Trail Fee (CAT)
+
+        Attributes:
+            sec_fee (str | Unset):
+            taf_fee (str | Unset):
+            orf_fee (str | Unset):
+            exchange_fee (str | Unset):
+            occ_fee (str | Unset):
+            cat_fee (str | Unset):
+    """
+
+    sec_fee: str | Unset = UNSET
+    taf_fee: str | Unset = UNSET
+    orf_fee: str | Unset = UNSET
+    exchange_fee: str | Unset = UNSET
+    occ_fee: str | Unset = UNSET
+    cat_fee: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        sec_fee = self.sec_fee
+
+        taf_fee = self.taf_fee
+
+        orf_fee = self.orf_fee
+
+        exchange_fee = self.exchange_fee
+
+        occ_fee = self.occ_fee
+
+        cat_fee = self.cat_fee
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if sec_fee is not UNSET:
+            field_dict["secFee"] = sec_fee
+        if taf_fee is not UNSET:
+            field_dict["tafFee"] = taf_fee
+        if orf_fee is not UNSET:
+            field_dict["orfFee"] = orf_fee
+        if exchange_fee is not UNSET:
+            field_dict["exchangeFee"] = exchange_fee
+        if occ_fee is not UNSET:
+            field_dict["occFee"] = occ_fee
+        if cat_fee is not UNSET:
+            field_dict["catFee"] = cat_fee
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        sec_fee = d.pop("secFee", UNSET)
+
+        taf_fee = d.pop("tafFee", UNSET)
+
+        orf_fee = d.pop("orfFee", UNSET)
+
+        exchange_fee = d.pop("exchangeFee", UNSET)
+
+        occ_fee = d.pop("occFee", UNSET)
+
+        cat_fee = d.pop("catFee", UNSET)
+
+        com_hellopublic_userapigateway_api_rest_preflight_gateway_regulatory_fees = cls(
+            sec_fee=sec_fee,
+            taf_fee=taf_fee,
+            orf_fee=orf_fee,
+            exchange_fee=exchange_fee,
+            occ_fee=occ_fee,
+            cat_fee=cat_fee,
+        )
+
+        com_hellopublic_userapigateway_api_rest_preflight_gateway_regulatory_fees.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_preflight_gateway_regulatory_fees
+
+    @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