Skip to content

remote_key_manager

DeleteRemoteKeysJsonBody

Attributes:

Name Type Description
pubkeys List[str]

List of public keys to delete.
Source code in eth_2_key_manager_api_client/models/delete_remote_keys_json_body.py 
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
@attr.s(auto_attribs=True)
class DeleteRemoteKeysJsonBody:
    """
    Attributes:
        pubkeys (List[str]): List of public keys to delete.
    """

    pubkeys: List[str]
    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)

    def to_dict(self) -> Dict[str, Any]:
        pubkeys = self.pubkeys

        field_dict: Dict[str, Any] = {}
        field_dict.update(self.additional_properties)
        field_dict.update(
            {
                "pubkeys": pubkeys,
            }
        )

        return field_dict

    @classmethod
    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
        d = src_dict.copy()
        pubkeys = cast(List[str], d.pop("pubkeys"))

        delete_remote_keys_json_body = cls(
            pubkeys=pubkeys,
        )

        delete_remote_keys_json_body.additional_properties = d
        return delete_remote_keys_json_body

    @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

DeleteRemoteKeysResponseDataItem

Attributes:

Name Type Description
status DeleteRemoteKeysResponseDataItemStatus
  • deleted: key was active and removed
  • not_found: key was not found to be removed
  • error: unexpected condition meant the key could not be removed (the key was actually found, but we couldn't stop using it) - this would be a sign that making it active elsewhere would almost certainly cause you headaches / slashing conditions etc. Example: deleted.
message Union[Unset, str]

error message if status == error
Source code in eth_2_key_manager_api_client/models/delete_remote_keys_response_data_item.py 
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
@attr.s(auto_attribs=True)
class DeleteRemoteKeysResponseDataItem:
    """
    Attributes:
        status (DeleteRemoteKeysResponseDataItemStatus): - deleted: key was active and removed
            - not_found: key was not found to be removed
            - error: unexpected condition meant the key could not be removed (the key was actually found,
              but we couldn't stop using it) - this would be a sign that making it active elsewhere would
              almost certainly cause you headaches / slashing conditions etc.
             Example: deleted.
        message (Union[Unset, str]): error message if status == error
    """

    status: DeleteRemoteKeysResponseDataItemStatus
    message: Union[Unset, str] = UNSET
    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)

    def to_dict(self) -> Dict[str, Any]:
        status = self.status.value

        message = self.message

        field_dict: Dict[str, Any] = {}
        field_dict.update(self.additional_properties)
        field_dict.update(
            {
                "status": status,
            }
        )
        if message is not UNSET:
            field_dict["message"] = message

        return field_dict

    @classmethod
    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
        d = src_dict.copy()
        status = DeleteRemoteKeysResponseDataItemStatus(d.pop("status"))

        message = d.pop("message", UNSET)

        delete_remote_keys_response_data_item = cls(
            status=status,
            message=message,
        )

        delete_remote_keys_response_data_item.additional_properties = d
        return delete_remote_keys_response_data_item

    @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

DeleteRemoteKeysResponse

Attributes:

Name Type Description
data List[DeleteRemoteKeysResponseDataItem]

Deletion status of all keys in request.pubkeys in the same order.
Source code in eth_2_key_manager_api_client/models/delete_remote_keys_response.py 
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
@attr.s(auto_attribs=True)
class DeleteRemoteKeysResponse:
    """
    Attributes:
        data (List['DeleteRemoteKeysResponseDataItem']): Deletion status of all keys in `request.pubkeys` in the same
            order.
    """

    data: List["DeleteRemoteKeysResponseDataItem"]
    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)

    def to_dict(self) -> Dict[str, Any]:
        data = []
        for data_item_data in self.data:
            data_item = data_item_data.to_dict()

            data.append(data_item)

        field_dict: Dict[str, Any] = {}
        field_dict.update(self.additional_properties)
        field_dict.update(
            {
                "data": data,
            }
        )

        return field_dict

    @classmethod
    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
        from eth_2_key_manager_api_client.models.delete_remote_keys_response_data_item import (
            DeleteRemoteKeysResponseDataItem,
        )

        d = src_dict.copy()
        data = []
        _data = d.pop("data")
        for data_item_data in _data:
            data_item = DeleteRemoteKeysResponseDataItem.from_dict(data_item_data)

            data.append(data_item)

        delete_remote_keys_response = cls(
            data=data,
        )

        delete_remote_keys_response.additional_properties = d
        return delete_remote_keys_response

    @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

ImportRemoteKeysJsonBody

Attributes:

Name Type Description
remote_keys List[ImportRemoteKeysJsonBodyRemoteKeysItem]
Source code in eth_2_key_manager_api_client/models/import_remote_keys_json_body.py 
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
@attr.s(auto_attribs=True)
class ImportRemoteKeysJsonBody:
    """
    Attributes:
        remote_keys (List['ImportRemoteKeysJsonBodyRemoteKeysItem']):
    """

    remote_keys: List["ImportRemoteKeysJsonBodyRemoteKeysItem"]
    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)

    def to_dict(self) -> Dict[str, Any]:
        remote_keys = []
        for remote_keys_item_data in self.remote_keys:
            remote_keys_item = remote_keys_item_data.to_dict()

            remote_keys.append(remote_keys_item)

        field_dict: Dict[str, Any] = {}
        field_dict.update(self.additional_properties)
        field_dict.update(
            {
                "remote_keys": remote_keys,
            }
        )

        return field_dict

    @classmethod
    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
        from eth_2_key_manager_api_client.models.import_remote_keys_json_body_remote_keys_item import (
            ImportRemoteKeysJsonBodyRemoteKeysItem,
        )

        d = src_dict.copy()
        remote_keys = []
        _remote_keys = d.pop("remote_keys")
        for remote_keys_item_data in _remote_keys:
            remote_keys_item = ImportRemoteKeysJsonBodyRemoteKeysItem.from_dict(remote_keys_item_data)

            remote_keys.append(remote_keys_item)

        import_remote_keys_json_body = cls(
            remote_keys=remote_keys,
        )

        import_remote_keys_json_body.additional_properties = d
        return import_remote_keys_json_body

    @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

ImportRemoteKeysJsonBodyRemoteKeysItem

Attributes:

Name Type Description
pubkey str

The validator's BLS public key, uniquely identifying them. 48-bytes, hex encoded with 0x prefix, case insensitive. Example: 0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a.
url Union[Unset, str]

URL to API implementing EIP-3030: BLS Remote Signer HTTP API Example: https://remote.signer.
Source code in eth_2_key_manager_api_client/models/import_remote_keys_json_body_remote_keys_item.py 
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
@attr.s(auto_attribs=True)
class ImportRemoteKeysJsonBodyRemoteKeysItem:
    """
    Attributes:
        pubkey (str): The validator's BLS public key, uniquely identifying them. _48-bytes, hex encoded with 0x prefix,
            case insensitive._
             Example: 0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a.
        url (Union[Unset, str]): URL to API implementing EIP-3030: BLS Remote Signer HTTP API Example:
            https://remote.signer.
    """

    pubkey: str
    url: Union[Unset, str] = UNSET
    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)

    def to_dict(self) -> Dict[str, Any]:
        pubkey = self.pubkey
        url = self.url

        field_dict: Dict[str, Any] = {}
        field_dict.update(self.additional_properties)
        field_dict.update(
            {
                "pubkey": pubkey,
            }
        )
        if url is not UNSET:
            field_dict["url"] = url

        return field_dict

    @classmethod
    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
        d = src_dict.copy()
        pubkey = d.pop("pubkey")

        url = d.pop("url", UNSET)

        import_remote_keys_json_body_remote_keys_item = cls(
            pubkey=pubkey,
            url=url,
        )

        import_remote_keys_json_body_remote_keys_item.additional_properties = d
        return import_remote_keys_json_body_remote_keys_item

    @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

ImportRemoteKeysResponseDataItem

Attributes:

Name Type Description
status ImportRemoteKeysResponseDataItemStatus
  • imported: Remote key successfully imported to validator client permanent storage
  • duplicate: Remote key's pubkey is already known to the validator client
  • error: Any other status different to the above: I/O errors, etc. Example: imported.
message Union[Unset, str]

error message if status == error
Source code in eth_2_key_manager_api_client/models/import_remote_keys_response_data_item.py 
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
@attr.s(auto_attribs=True)
class ImportRemoteKeysResponseDataItem:
    """
    Attributes:
        status (ImportRemoteKeysResponseDataItemStatus): - imported: Remote key successfully imported to validator
            client permanent storage
            - duplicate: Remote key's pubkey is already known to the validator client
            - error: Any other status different to the above: I/O errors, etc.
             Example: imported.
        message (Union[Unset, str]): error message if status == error
    """

    status: ImportRemoteKeysResponseDataItemStatus
    message: Union[Unset, str] = UNSET
    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)

    def to_dict(self) -> Dict[str, Any]:
        status = self.status.value

        message = self.message

        field_dict: Dict[str, Any] = {}
        field_dict.update(self.additional_properties)
        field_dict.update(
            {
                "status": status,
            }
        )
        if message is not UNSET:
            field_dict["message"] = message

        return field_dict

    @classmethod
    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
        d = src_dict.copy()
        status = ImportRemoteKeysResponseDataItemStatus(d.pop("status"))

        message = d.pop("message", UNSET)

        import_remote_keys_response_data_item = cls(
            status=status,
            message=message,
        )

        import_remote_keys_response_data_item.additional_properties = d
        return import_remote_keys_response_data_item

    @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

ImportRemoteKeysResponse

Attributes:

Name Type Description
data List[ImportRemoteKeysResponseDataItem]

Status result of each request.remote_keys with same length and order of request.remote_keys
Source code in eth_2_key_manager_api_client/models/import_remote_keys_response.py 
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
@attr.s(auto_attribs=True)
class ImportRemoteKeysResponse:
    """
    Attributes:
        data (List['ImportRemoteKeysResponseDataItem']): Status result of each `request.remote_keys` with same length
            and order of `request.remote_keys`
    """

    data: List["ImportRemoteKeysResponseDataItem"]
    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)

    def to_dict(self) -> Dict[str, Any]:
        data = []
        for data_item_data in self.data:
            data_item = data_item_data.to_dict()

            data.append(data_item)

        field_dict: Dict[str, Any] = {}
        field_dict.update(self.additional_properties)
        field_dict.update(
            {
                "data": data,
            }
        )

        return field_dict

    @classmethod
    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
        from eth_2_key_manager_api_client.models.import_remote_keys_response_data_item import (
            ImportRemoteKeysResponseDataItem,
        )

        d = src_dict.copy()
        data = []
        _data = d.pop("data")
        for data_item_data in _data:
            data_item = ImportRemoteKeysResponseDataItem.from_dict(data_item_data)

            data.append(data_item)

        import_remote_keys_response = cls(
            data=data,
        )

        import_remote_keys_response.additional_properties = d
        return import_remote_keys_response

    @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

ImportRemoteSignerDefinition

Attributes:

Name Type Description
pubkey str

The validator's BLS public key, uniquely identifying them. 48-bytes, hex encoded with 0x prefix, case insensitive. Example: 0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a.
url Union[Unset, str]

URL to API implementing EIP-3030: BLS Remote Signer HTTP API Example: https://remote.signer.
Source code in eth_2_key_manager_api_client/models/import_remote_signer_definition.py 
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
@attr.s(auto_attribs=True)
class ImportRemoteSignerDefinition:
    """
    Attributes:
        pubkey (str): The validator's BLS public key, uniquely identifying them. _48-bytes, hex encoded with 0x prefix,
            case insensitive._
             Example: 0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a.
        url (Union[Unset, str]): URL to API implementing EIP-3030: BLS Remote Signer HTTP API Example:
            https://remote.signer.
    """

    pubkey: str
    url: Union[Unset, str] = UNSET
    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)

    def to_dict(self) -> Dict[str, Any]:
        pubkey = self.pubkey
        url = self.url

        field_dict: Dict[str, Any] = {}
        field_dict.update(self.additional_properties)
        field_dict.update(
            {
                "pubkey": pubkey,
            }
        )
        if url is not UNSET:
            field_dict["url"] = url

        return field_dict

    @classmethod
    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
        d = src_dict.copy()
        pubkey = d.pop("pubkey")

        url = d.pop("url", UNSET)

        import_remote_signer_definition = cls(
            pubkey=pubkey,
            url=url,
        )

        import_remote_signer_definition.additional_properties = d
        return import_remote_signer_definition

    @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

ListRemoteKeysResponseDataItem

Attributes:

Name Type Description
pubkey str

The validator's BLS public key, uniquely identifying them. 48-bytes, hex encoded with 0x prefix, case insensitive. Example: 0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a.
url Union[Unset, str]

URL to API implementing EIP-3030: BLS Remote Signer HTTP API Example: https://remote.signer.
readonly Union[Unset, bool]

The signer associated with this pubkey cannot be deleted from the API
Source code in eth_2_key_manager_api_client/models/list_remote_keys_response_data_item.py 
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
@attr.s(auto_attribs=True)
class ListRemoteKeysResponseDataItem:
    """
    Attributes:
        pubkey (str): The validator's BLS public key, uniquely identifying them. _48-bytes, hex encoded with 0x prefix,
            case insensitive._
             Example: 0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a.
        url (Union[Unset, str]): URL to API implementing EIP-3030: BLS Remote Signer HTTP API Example:
            https://remote.signer.
        readonly (Union[Unset, bool]): The signer associated with this pubkey cannot be deleted from the API
    """

    pubkey: str
    url: Union[Unset, str] = UNSET
    readonly: Union[Unset, bool] = UNSET
    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)

    def to_dict(self) -> Dict[str, Any]:
        pubkey = self.pubkey
        url = self.url
        readonly = self.readonly

        field_dict: Dict[str, Any] = {}
        field_dict.update(self.additional_properties)
        field_dict.update(
            {
                "pubkey": pubkey,
            }
        )
        if url is not UNSET:
            field_dict["url"] = url
        if readonly is not UNSET:
            field_dict["readonly"] = readonly

        return field_dict

    @classmethod
    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
        d = src_dict.copy()
        pubkey = d.pop("pubkey")

        url = d.pop("url", UNSET)

        readonly = d.pop("readonly", UNSET)

        list_remote_keys_response_data_item = cls(
            pubkey=pubkey,
            url=url,
            readonly=readonly,
        )

        list_remote_keys_response_data_item.additional_properties = d
        return list_remote_keys_response_data_item

    @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

ListRemoteKeysResponse

Attributes:

Name Type Description
data List[ListRemoteKeysResponseDataItem]
Source code in eth_2_key_manager_api_client/models/list_remote_keys_response.py 
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
@attr.s(auto_attribs=True)
class ListRemoteKeysResponse:
    """
    Attributes:
        data (List['ListRemoteKeysResponseDataItem']):
    """

    data: List["ListRemoteKeysResponseDataItem"]
    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)

    def to_dict(self) -> Dict[str, Any]:
        data = []
        for data_item_data in self.data:
            data_item = data_item_data.to_dict()

            data.append(data_item)

        field_dict: Dict[str, Any] = {}
        field_dict.update(self.additional_properties)
        field_dict.update(
            {
                "data": data,
            }
        )

        return field_dict

    @classmethod
    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
        from eth_2_key_manager_api_client.models.list_remote_keys_response_data_item import (
            ListRemoteKeysResponseDataItem,
        )

        d = src_dict.copy()
        data = []
        _data = d.pop("data")
        for data_item_data in _data:
            data_item = ListRemoteKeysResponseDataItem.from_dict(data_item_data)

            data.append(data_item)

        list_remote_keys_response = cls(
            data=data,
        )

        list_remote_keys_response.additional_properties = d
        return list_remote_keys_response

    @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