Initial commit: Email alerts application

venv/lib/python3.11/site-packages/twilio/rest/trunking/TrunkingBase.py

@@ -0,0 +1,43 @@
+r"""
+  This code was generated by
+  ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+   |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+   |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+  NOTE: This class is auto generated by OpenAPI Generator.
+  https://openapi-generator.tech
+  Do not edit the class manually.
+"""
+
+from typing import Optional
+
+from twilio.base.domain import Domain
+from twilio.rest import Client
+from twilio.rest.trunking.v1 import V1
+
+
+class TrunkingBase(Domain):
+    def __init__(self, twilio: Client):
+        """
+        Initialize the Trunking Domain
+
+        :returns: Domain for Trunking
+        """
+        super().__init__(twilio, "https://trunking.twilio.com")
+        self._v1: Optional[V1] = None
+
+    @property
+    def v1(self) -> V1:
+        """
+        :returns: Versions v1 of Trunking
+        """
+        if self._v1 is None:
+            self._v1 = V1(self)
+        return self._v1
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Trunking>"

venv/lib/python3.11/site-packages/twilio/rest/trunking/__init__.py

@@ -0,0 +1,15 @@
+from warnings import warn
+
+from twilio.rest.trunking.TrunkingBase import TrunkingBase
+from twilio.rest.trunking.v1.trunk import TrunkList
+
+
+class Trunking(TrunkingBase):
+    @property
+    def trunks(self) -> TrunkList:
+        warn(
+            "trunks is deprecated. Use v1.trunks instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.v1.trunks

venv/lib/python3.11/site-packages/twilio/rest/trunking/v1/__init__.py

@@ -0,0 +1,42 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Trunking
+    This is the public Twilio REST API.
+
+    NOTE: This class is auto generated by OpenAPI Generator.
+    https://openapi-generator.tech
+    Do not edit the class manually.
+"""
+
+from typing import Optional
+from twilio.base.version import Version
+from twilio.base.domain import Domain
+from twilio.rest.trunking.v1.trunk import TrunkList
+
+
+class V1(Version):
+    def __init__(self, domain: Domain):
+        """
+        Initialize the V1 version of Trunking
+
+        :param domain: The Twilio.trunking domain
+        """
+        super().__init__(domain, "v1")
+        self._trunks: Optional[TrunkList] = None
+
+    @property
+    def trunks(self) -> TrunkList:
+        if self._trunks is None:
+            self._trunks = TrunkList(self)
+        return self._trunks
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Trunking.V1>"

venv/lib/python3.11/site-packages/twilio/rest/trunking/v1/trunk/__init__.py

@@ -0,0 +1,852 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Trunking
+    This is the public Twilio REST API.
+
+    NOTE: This class is auto generated by OpenAPI Generator.
+    https://openapi-generator.tech
+    Do not edit the class manually.
+"""
+
+
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Union, Iterator, AsyncIterator
+from twilio.base import deserialize, values
+from twilio.base.instance_context import InstanceContext
+from twilio.base.instance_resource import InstanceResource
+from twilio.base.list_resource import ListResource
+from twilio.base.version import Version
+from twilio.base.page import Page
+from twilio.rest.trunking.v1.trunk.credential_list import CredentialListList
+from twilio.rest.trunking.v1.trunk.ip_access_control_list import IpAccessControlListList
+from twilio.rest.trunking.v1.trunk.origination_url import OriginationUrlList
+from twilio.rest.trunking.v1.trunk.phone_number import PhoneNumberList
+from twilio.rest.trunking.v1.trunk.recording import RecordingList
+
+
+class TrunkInstance(InstanceResource):
+    class TransferCallerId(object):
+        FROM_TRANSFEREE = "from-transferee"
+        FROM_TRANSFEROR = "from-transferor"
+
+    class TransferSetting(object):
+        DISABLE_ALL = "disable-all"
+        ENABLE_ALL = "enable-all"
+        SIP_ONLY = "sip-only"
+
+    """
+    :ivar account_sid: The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the Trunk resource.
+    :ivar domain_name: The unique address you reserve on Twilio to which you route your SIP traffic. Domain names can contain letters, digits, and `-` and must end with `pstn.twilio.com`. See [Termination Settings](https://www.twilio.com/docs/sip-trunking#termination) for more information.
+    :ivar disaster_recovery_method: The HTTP method we use to call the `disaster_recovery_url`. Can be: `GET` or `POST`.
+    :ivar disaster_recovery_url: The URL we call using the `disaster_recovery_method` if an error occurs while sending SIP traffic towards the configured Origination URL. We retrieve TwiML from this URL and execute the instructions like any other normal TwiML call. See [Disaster Recovery](https://www.twilio.com/docs/sip-trunking#disaster-recovery) for more information.
+    :ivar friendly_name: The string that you assigned to describe the resource.
+    :ivar secure: Whether Secure Trunking is enabled for the trunk. If enabled, all calls going through the trunk will be secure using SRTP for media and TLS for signaling. If disabled, then RTP will be used for media. See [Secure Trunking](https://www.twilio.com/docs/sip-trunking#securetrunking) for more information.
+    :ivar recording: The recording settings for the trunk. Can be: `do-not-record`, `record-from-ringing`, `record-from-answer`. If set to `record-from-ringing` or `record-from-answer`, all calls going through the trunk will be recorded. The only way to change recording parameters is on a sub-resource of a Trunk after it has been created. e.g.`/Trunks/[Trunk_SID]/Recording -XPOST -d'Mode=record-from-answer'`. See [Recording](https://www.twilio.com/docs/sip-trunking#recording) for more information.
+    :ivar transfer_mode: 
+    :ivar transfer_caller_id: 
+    :ivar cnam_lookup_enabled: Whether Caller ID Name (CNAM) lookup is enabled for the trunk. If enabled, all inbound calls to the SIP Trunk from the United States and Canada automatically perform a CNAM Lookup and display Caller ID data on your phone. See [CNAM Lookups](https://www.twilio.com/docs/sip-trunking#CNAM) for more information.
+    :ivar auth_type: The types of authentication mapped to the domain. Can be: `IP_ACL` and `CREDENTIAL_LIST`. If both are mapped, the values are returned in a comma delimited list. If empty, the domain will not receive any traffic.
+    :ivar auth_type_set: Reserved.
+    :ivar date_created: The date and time in GMT when the resource was created specified in [RFC 2822](https://www.ietf.org/rfc/rfc2822.txt) format.
+    :ivar date_updated: The date and time in GMT when the resource was last updated specified in [RFC 2822](https://www.ietf.org/rfc/rfc2822.txt) format.
+    :ivar sid: The unique string that we created to identify the Trunk resource.
+    :ivar url: The absolute URL of the resource.
+    :ivar links: The URLs of related resources.
+    """
+
+    def __init__(
+        self, version: Version, payload: Dict[str, Any], sid: Optional[str] = None
+    ):
+        super().__init__(version)
+
+        self.account_sid: Optional[str] = payload.get("account_sid")
+        self.domain_name: Optional[str] = payload.get("domain_name")
+        self.disaster_recovery_method: Optional[str] = payload.get(
+            "disaster_recovery_method"
+        )
+        self.disaster_recovery_url: Optional[str] = payload.get("disaster_recovery_url")
+        self.friendly_name: Optional[str] = payload.get("friendly_name")
+        self.secure: Optional[bool] = payload.get("secure")
+        self.recording: Optional[Dict[str, object]] = payload.get("recording")
+        self.transfer_mode: Optional["TrunkInstance.TransferSetting"] = payload.get(
+            "transfer_mode"
+        )
+        self.transfer_caller_id: Optional[
+            "TrunkInstance.TransferCallerId"
+        ] = payload.get("transfer_caller_id")
+        self.cnam_lookup_enabled: Optional[bool] = payload.get("cnam_lookup_enabled")
+        self.auth_type: Optional[str] = payload.get("auth_type")
+        self.auth_type_set: Optional[List[str]] = payload.get("auth_type_set")
+        self.date_created: Optional[datetime] = deserialize.iso8601_datetime(
+            payload.get("date_created")
+        )
+        self.date_updated: Optional[datetime] = deserialize.iso8601_datetime(
+            payload.get("date_updated")
+        )
+        self.sid: Optional[str] = payload.get("sid")
+        self.url: Optional[str] = payload.get("url")
+        self.links: Optional[Dict[str, object]] = payload.get("links")
+
+        self._solution = {
+            "sid": sid or self.sid,
+        }
+        self._context: Optional[TrunkContext] = None
+
+    @property
+    def _proxy(self) -> "TrunkContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: TrunkContext for this TrunkInstance
+        """
+        if self._context is None:
+            self._context = TrunkContext(
+                self._version,
+                sid=self._solution["sid"],
+            )
+        return self._context
+
+    def delete(self) -> bool:
+        """
+        Deletes the TrunkInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return self._proxy.delete()
+
+    async def delete_async(self) -> bool:
+        """
+        Asynchronous coroutine that deletes the TrunkInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return await self._proxy.delete_async()
+
+    def fetch(self) -> "TrunkInstance":
+        """
+        Fetch the TrunkInstance
+
+
+        :returns: The fetched TrunkInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "TrunkInstance":
+        """
+        Asynchronous coroutine to fetch the TrunkInstance
+
+
+        :returns: The fetched TrunkInstance
+        """
+        return await self._proxy.fetch_async()
+
+    def update(
+        self,
+        friendly_name: Union[str, object] = values.unset,
+        domain_name: Union[str, object] = values.unset,
+        disaster_recovery_url: Union[str, object] = values.unset,
+        disaster_recovery_method: Union[str, object] = values.unset,
+        transfer_mode: Union["TrunkInstance.TransferSetting", object] = values.unset,
+        secure: Union[bool, object] = values.unset,
+        cnam_lookup_enabled: Union[bool, object] = values.unset,
+        transfer_caller_id: Union[
+            "TrunkInstance.TransferCallerId", object
+        ] = values.unset,
+    ) -> "TrunkInstance":
+        """
+        Update the TrunkInstance
+
+        :param friendly_name: A descriptive string that you create to describe the resource. It can be up to 64 characters long.
+        :param domain_name: The unique address you reserve on Twilio to which you route your SIP traffic. Domain names can contain letters, digits, and `-` and must end with `pstn.twilio.com`. See [Termination Settings](https://www.twilio.com/docs/sip-trunking#termination) for more information.
+        :param disaster_recovery_url: The URL we should call using the `disaster_recovery_method` if an error occurs while sending SIP traffic towards the configured Origination URL. We retrieve TwiML from the URL and execute the instructions like any other normal TwiML call. See [Disaster Recovery](https://www.twilio.com/docs/sip-trunking#disaster-recovery) for more information.
+        :param disaster_recovery_method: The HTTP method we should use to call the `disaster_recovery_url`. Can be: `GET` or `POST`.
+        :param transfer_mode:
+        :param secure: Whether Secure Trunking is enabled for the trunk. If enabled, all calls going through the trunk will be secure using SRTP for media and TLS for signaling. If disabled, then RTP will be used for media. See [Secure Trunking](https://www.twilio.com/docs/sip-trunking#securetrunking) for more information.
+        :param cnam_lookup_enabled: Whether Caller ID Name (CNAM) lookup should be enabled for the trunk. If enabled, all inbound calls to the SIP Trunk from the United States and Canada automatically perform a CNAM Lookup and display Caller ID data on your phone. See [CNAM Lookups](https://www.twilio.com/docs/sip-trunking#CNAM) for more information.
+        :param transfer_caller_id:
+
+        :returns: The updated TrunkInstance
+        """
+        return self._proxy.update(
+            friendly_name=friendly_name,
+            domain_name=domain_name,
+            disaster_recovery_url=disaster_recovery_url,
+            disaster_recovery_method=disaster_recovery_method,
+            transfer_mode=transfer_mode,
+            secure=secure,
+            cnam_lookup_enabled=cnam_lookup_enabled,
+            transfer_caller_id=transfer_caller_id,
+        )
+
+    async def update_async(
+        self,
+        friendly_name: Union[str, object] = values.unset,
+        domain_name: Union[str, object] = values.unset,
+        disaster_recovery_url: Union[str, object] = values.unset,
+        disaster_recovery_method: Union[str, object] = values.unset,
+        transfer_mode: Union["TrunkInstance.TransferSetting", object] = values.unset,
+        secure: Union[bool, object] = values.unset,
+        cnam_lookup_enabled: Union[bool, object] = values.unset,
+        transfer_caller_id: Union[
+            "TrunkInstance.TransferCallerId", object
+        ] = values.unset,
+    ) -> "TrunkInstance":
+        """
+        Asynchronous coroutine to update the TrunkInstance
+
+        :param friendly_name: A descriptive string that you create to describe the resource. It can be up to 64 characters long.
+        :param domain_name: The unique address you reserve on Twilio to which you route your SIP traffic. Domain names can contain letters, digits, and `-` and must end with `pstn.twilio.com`. See [Termination Settings](https://www.twilio.com/docs/sip-trunking#termination) for more information.
+        :param disaster_recovery_url: The URL we should call using the `disaster_recovery_method` if an error occurs while sending SIP traffic towards the configured Origination URL. We retrieve TwiML from the URL and execute the instructions like any other normal TwiML call. See [Disaster Recovery](https://www.twilio.com/docs/sip-trunking#disaster-recovery) for more information.
+        :param disaster_recovery_method: The HTTP method we should use to call the `disaster_recovery_url`. Can be: `GET` or `POST`.
+        :param transfer_mode:
+        :param secure: Whether Secure Trunking is enabled for the trunk. If enabled, all calls going through the trunk will be secure using SRTP for media and TLS for signaling. If disabled, then RTP will be used for media. See [Secure Trunking](https://www.twilio.com/docs/sip-trunking#securetrunking) for more information.
+        :param cnam_lookup_enabled: Whether Caller ID Name (CNAM) lookup should be enabled for the trunk. If enabled, all inbound calls to the SIP Trunk from the United States and Canada automatically perform a CNAM Lookup and display Caller ID data on your phone. See [CNAM Lookups](https://www.twilio.com/docs/sip-trunking#CNAM) for more information.
+        :param transfer_caller_id:
+
+        :returns: The updated TrunkInstance
+        """
+        return await self._proxy.update_async(
+            friendly_name=friendly_name,
+            domain_name=domain_name,
+            disaster_recovery_url=disaster_recovery_url,
+            disaster_recovery_method=disaster_recovery_method,
+            transfer_mode=transfer_mode,
+            secure=secure,
+            cnam_lookup_enabled=cnam_lookup_enabled,
+            transfer_caller_id=transfer_caller_id,
+        )
+
+    @property
+    def credentials_lists(self) -> CredentialListList:
+        """
+        Access the credentials_lists
+        """
+        return self._proxy.credentials_lists
+
+    @property
+    def ip_access_control_lists(self) -> IpAccessControlListList:
+        """
+        Access the ip_access_control_lists
+        """
+        return self._proxy.ip_access_control_lists
+
+    @property
+    def origination_urls(self) -> OriginationUrlList:
+        """
+        Access the origination_urls
+        """
+        return self._proxy.origination_urls
+
+    @property
+    def phone_numbers(self) -> PhoneNumberList:
+        """
+        Access the phone_numbers
+        """
+        return self._proxy.phone_numbers
+
+    @property
+    def recordings(self) -> RecordingList:
+        """
+        Access the recordings
+        """
+        return self._proxy.recordings
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        context = " ".join("{}={}".format(k, v) for k, v in self._solution.items())
+        return "<Twilio.Trunking.V1.TrunkInstance {}>".format(context)
+
+
+class TrunkContext(InstanceContext):
+    def __init__(self, version: Version, sid: str):
+        """
+        Initialize the TrunkContext
+
+        :param version: Version that contains the resource
+        :param sid: The unique string that we created to identify the OriginationUrl resource to update.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "sid": sid,
+        }
+        self._uri = "/Trunks/{sid}".format(**self._solution)
+
+        self._credentials_lists: Optional[CredentialListList] = None
+        self._ip_access_control_lists: Optional[IpAccessControlListList] = None
+        self._origination_urls: Optional[OriginationUrlList] = None
+        self._phone_numbers: Optional[PhoneNumberList] = None
+        self._recordings: Optional[RecordingList] = None
+
+    def delete(self) -> bool:
+        """
+        Deletes the TrunkInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return self._version.delete(
+            method="DELETE",
+            uri=self._uri,
+        )
+
+    async def delete_async(self) -> bool:
+        """
+        Asynchronous coroutine that deletes the TrunkInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return await self._version.delete_async(
+            method="DELETE",
+            uri=self._uri,
+        )
+
+    def fetch(self) -> TrunkInstance:
+        """
+        Fetch the TrunkInstance
+
+
+        :returns: The fetched TrunkInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return TrunkInstance(
+            self._version,
+            payload,
+            sid=self._solution["sid"],
+        )
+
+    async def fetch_async(self) -> TrunkInstance:
+        """
+        Asynchronous coroutine to fetch the TrunkInstance
+
+
+        :returns: The fetched TrunkInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return TrunkInstance(
+            self._version,
+            payload,
+            sid=self._solution["sid"],
+        )
+
+    def update(
+        self,
+        friendly_name: Union[str, object] = values.unset,
+        domain_name: Union[str, object] = values.unset,
+        disaster_recovery_url: Union[str, object] = values.unset,
+        disaster_recovery_method: Union[str, object] = values.unset,
+        transfer_mode: Union["TrunkInstance.TransferSetting", object] = values.unset,
+        secure: Union[bool, object] = values.unset,
+        cnam_lookup_enabled: Union[bool, object] = values.unset,
+        transfer_caller_id: Union[
+            "TrunkInstance.TransferCallerId", object
+        ] = values.unset,
+    ) -> TrunkInstance:
+        """
+        Update the TrunkInstance
+
+        :param friendly_name: A descriptive string that you create to describe the resource. It can be up to 64 characters long.
+        :param domain_name: The unique address you reserve on Twilio to which you route your SIP traffic. Domain names can contain letters, digits, and `-` and must end with `pstn.twilio.com`. See [Termination Settings](https://www.twilio.com/docs/sip-trunking#termination) for more information.
+        :param disaster_recovery_url: The URL we should call using the `disaster_recovery_method` if an error occurs while sending SIP traffic towards the configured Origination URL. We retrieve TwiML from the URL and execute the instructions like any other normal TwiML call. See [Disaster Recovery](https://www.twilio.com/docs/sip-trunking#disaster-recovery) for more information.
+        :param disaster_recovery_method: The HTTP method we should use to call the `disaster_recovery_url`. Can be: `GET` or `POST`.
+        :param transfer_mode:
+        :param secure: Whether Secure Trunking is enabled for the trunk. If enabled, all calls going through the trunk will be secure using SRTP for media and TLS for signaling. If disabled, then RTP will be used for media. See [Secure Trunking](https://www.twilio.com/docs/sip-trunking#securetrunking) for more information.
+        :param cnam_lookup_enabled: Whether Caller ID Name (CNAM) lookup should be enabled for the trunk. If enabled, all inbound calls to the SIP Trunk from the United States and Canada automatically perform a CNAM Lookup and display Caller ID data on your phone. See [CNAM Lookups](https://www.twilio.com/docs/sip-trunking#CNAM) for more information.
+        :param transfer_caller_id:
+
+        :returns: The updated TrunkInstance
+        """
+        data = values.of(
+            {
+                "FriendlyName": friendly_name,
+                "DomainName": domain_name,
+                "DisasterRecoveryUrl": disaster_recovery_url,
+                "DisasterRecoveryMethod": disaster_recovery_method,
+                "TransferMode": transfer_mode,
+                "Secure": secure,
+                "CnamLookupEnabled": cnam_lookup_enabled,
+                "TransferCallerId": transfer_caller_id,
+            }
+        )
+
+        payload = self._version.update(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return TrunkInstance(self._version, payload, sid=self._solution["sid"])
+
+    async def update_async(
+        self,
+        friendly_name: Union[str, object] = values.unset,
+        domain_name: Union[str, object] = values.unset,
+        disaster_recovery_url: Union[str, object] = values.unset,
+        disaster_recovery_method: Union[str, object] = values.unset,
+        transfer_mode: Union["TrunkInstance.TransferSetting", object] = values.unset,
+        secure: Union[bool, object] = values.unset,
+        cnam_lookup_enabled: Union[bool, object] = values.unset,
+        transfer_caller_id: Union[
+            "TrunkInstance.TransferCallerId", object
+        ] = values.unset,
+    ) -> TrunkInstance:
+        """
+        Asynchronous coroutine to update the TrunkInstance
+
+        :param friendly_name: A descriptive string that you create to describe the resource. It can be up to 64 characters long.
+        :param domain_name: The unique address you reserve on Twilio to which you route your SIP traffic. Domain names can contain letters, digits, and `-` and must end with `pstn.twilio.com`. See [Termination Settings](https://www.twilio.com/docs/sip-trunking#termination) for more information.
+        :param disaster_recovery_url: The URL we should call using the `disaster_recovery_method` if an error occurs while sending SIP traffic towards the configured Origination URL. We retrieve TwiML from the URL and execute the instructions like any other normal TwiML call. See [Disaster Recovery](https://www.twilio.com/docs/sip-trunking#disaster-recovery) for more information.
+        :param disaster_recovery_method: The HTTP method we should use to call the `disaster_recovery_url`. Can be: `GET` or `POST`.
+        :param transfer_mode:
+        :param secure: Whether Secure Trunking is enabled for the trunk. If enabled, all calls going through the trunk will be secure using SRTP for media and TLS for signaling. If disabled, then RTP will be used for media. See [Secure Trunking](https://www.twilio.com/docs/sip-trunking#securetrunking) for more information.
+        :param cnam_lookup_enabled: Whether Caller ID Name (CNAM) lookup should be enabled for the trunk. If enabled, all inbound calls to the SIP Trunk from the United States and Canada automatically perform a CNAM Lookup and display Caller ID data on your phone. See [CNAM Lookups](https://www.twilio.com/docs/sip-trunking#CNAM) for more information.
+        :param transfer_caller_id:
+
+        :returns: The updated TrunkInstance
+        """
+        data = values.of(
+            {
+                "FriendlyName": friendly_name,
+                "DomainName": domain_name,
+                "DisasterRecoveryUrl": disaster_recovery_url,
+                "DisasterRecoveryMethod": disaster_recovery_method,
+                "TransferMode": transfer_mode,
+                "Secure": secure,
+                "CnamLookupEnabled": cnam_lookup_enabled,
+                "TransferCallerId": transfer_caller_id,
+            }
+        )
+
+        payload = await self._version.update_async(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return TrunkInstance(self._version, payload, sid=self._solution["sid"])
+
+    @property
+    def credentials_lists(self) -> CredentialListList:
+        """
+        Access the credentials_lists
+        """
+        if self._credentials_lists is None:
+            self._credentials_lists = CredentialListList(
+                self._version,
+                self._solution["sid"],
+            )
+        return self._credentials_lists
+
+    @property
+    def ip_access_control_lists(self) -> IpAccessControlListList:
+        """
+        Access the ip_access_control_lists
+        """
+        if self._ip_access_control_lists is None:
+            self._ip_access_control_lists = IpAccessControlListList(
+                self._version,
+                self._solution["sid"],
+            )
+        return self._ip_access_control_lists
+
+    @property
+    def origination_urls(self) -> OriginationUrlList:
+        """
+        Access the origination_urls
+        """
+        if self._origination_urls is None:
+            self._origination_urls = OriginationUrlList(
+                self._version,
+                self._solution["sid"],
+            )
+        return self._origination_urls
+
+    @property
+    def phone_numbers(self) -> PhoneNumberList:
+        """
+        Access the phone_numbers
+        """
+        if self._phone_numbers is None:
+            self._phone_numbers = PhoneNumberList(
+                self._version,
+                self._solution["sid"],
+            )
+        return self._phone_numbers
+
+    @property
+    def recordings(self) -> RecordingList:
+        """
+        Access the recordings
+        """
+        if self._recordings is None:
+            self._recordings = RecordingList(
+                self._version,
+                self._solution["sid"],
+            )
+        return self._recordings
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        context = " ".join("{}={}".format(k, v) for k, v in self._solution.items())
+        return "<Twilio.Trunking.V1.TrunkContext {}>".format(context)
+
+
+class TrunkPage(Page):
+    def get_instance(self, payload: Dict[str, Any]) -> TrunkInstance:
+        """
+        Build an instance of TrunkInstance
+
+        :param payload: Payload response from the API
+        """
+        return TrunkInstance(self._version, payload)
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Trunking.V1.TrunkPage>"
+
+
+class TrunkList(ListResource):
+    def __init__(self, version: Version):
+        """
+        Initialize the TrunkList
+
+        :param version: Version that contains the resource
+
+        """
+        super().__init__(version)
+
+        self._uri = "/Trunks"
+
+    def create(
+        self,
+        friendly_name: Union[str, object] = values.unset,
+        domain_name: Union[str, object] = values.unset,
+        disaster_recovery_url: Union[str, object] = values.unset,
+        disaster_recovery_method: Union[str, object] = values.unset,
+        transfer_mode: Union["TrunkInstance.TransferSetting", object] = values.unset,
+        secure: Union[bool, object] = values.unset,
+        cnam_lookup_enabled: Union[bool, object] = values.unset,
+        transfer_caller_id: Union[
+            "TrunkInstance.TransferCallerId", object
+        ] = values.unset,
+    ) -> TrunkInstance:
+        """
+        Create the TrunkInstance
+
+        :param friendly_name: A descriptive string that you create to describe the resource. It can be up to 64 characters long.
+        :param domain_name: The unique address you reserve on Twilio to which you route your SIP traffic. Domain names can contain letters, digits, and `-` and must end with `pstn.twilio.com`. See [Termination Settings](https://www.twilio.com/docs/sip-trunking#termination) for more information.
+        :param disaster_recovery_url: The URL we should call using the `disaster_recovery_method` if an error occurs while sending SIP traffic towards the configured Origination URL. We retrieve TwiML from the URL and execute the instructions like any other normal TwiML call. See [Disaster Recovery](https://www.twilio.com/docs/sip-trunking#disaster-recovery) for more information.
+        :param disaster_recovery_method: The HTTP method we should use to call the `disaster_recovery_url`. Can be: `GET` or `POST`.
+        :param transfer_mode:
+        :param secure: Whether Secure Trunking is enabled for the trunk. If enabled, all calls going through the trunk will be secure using SRTP for media and TLS for signaling. If disabled, then RTP will be used for media. See [Secure Trunking](https://www.twilio.com/docs/sip-trunking#securetrunking) for more information.
+        :param cnam_lookup_enabled: Whether Caller ID Name (CNAM) lookup should be enabled for the trunk. If enabled, all inbound calls to the SIP Trunk from the United States and Canada automatically perform a CNAM Lookup and display Caller ID data on your phone. See [CNAM Lookups](https://www.twilio.com/docs/sip-trunking#CNAM) for more information.
+        :param transfer_caller_id:
+
+        :returns: The created TrunkInstance
+        """
+        data = values.of(
+            {
+                "FriendlyName": friendly_name,
+                "DomainName": domain_name,
+                "DisasterRecoveryUrl": disaster_recovery_url,
+                "DisasterRecoveryMethod": disaster_recovery_method,
+                "TransferMode": transfer_mode,
+                "Secure": secure,
+                "CnamLookupEnabled": cnam_lookup_enabled,
+                "TransferCallerId": transfer_caller_id,
+            }
+        )
+
+        payload = self._version.create(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return TrunkInstance(self._version, payload)
+
+    async def create_async(
+        self,
+        friendly_name: Union[str, object] = values.unset,
+        domain_name: Union[str, object] = values.unset,
+        disaster_recovery_url: Union[str, object] = values.unset,
+        disaster_recovery_method: Union[str, object] = values.unset,
+        transfer_mode: Union["TrunkInstance.TransferSetting", object] = values.unset,
+        secure: Union[bool, object] = values.unset,
+        cnam_lookup_enabled: Union[bool, object] = values.unset,
+        transfer_caller_id: Union[
+            "TrunkInstance.TransferCallerId", object
+        ] = values.unset,
+    ) -> TrunkInstance:
+        """
+        Asynchronously create the TrunkInstance
+
+        :param friendly_name: A descriptive string that you create to describe the resource. It can be up to 64 characters long.
+        :param domain_name: The unique address you reserve on Twilio to which you route your SIP traffic. Domain names can contain letters, digits, and `-` and must end with `pstn.twilio.com`. See [Termination Settings](https://www.twilio.com/docs/sip-trunking#termination) for more information.
+        :param disaster_recovery_url: The URL we should call using the `disaster_recovery_method` if an error occurs while sending SIP traffic towards the configured Origination URL. We retrieve TwiML from the URL and execute the instructions like any other normal TwiML call. See [Disaster Recovery](https://www.twilio.com/docs/sip-trunking#disaster-recovery) for more information.
+        :param disaster_recovery_method: The HTTP method we should use to call the `disaster_recovery_url`. Can be: `GET` or `POST`.
+        :param transfer_mode:
+        :param secure: Whether Secure Trunking is enabled for the trunk. If enabled, all calls going through the trunk will be secure using SRTP for media and TLS for signaling. If disabled, then RTP will be used for media. See [Secure Trunking](https://www.twilio.com/docs/sip-trunking#securetrunking) for more information.
+        :param cnam_lookup_enabled: Whether Caller ID Name (CNAM) lookup should be enabled for the trunk. If enabled, all inbound calls to the SIP Trunk from the United States and Canada automatically perform a CNAM Lookup and display Caller ID data on your phone. See [CNAM Lookups](https://www.twilio.com/docs/sip-trunking#CNAM) for more information.
+        :param transfer_caller_id:
+
+        :returns: The created TrunkInstance
+        """
+        data = values.of(
+            {
+                "FriendlyName": friendly_name,
+                "DomainName": domain_name,
+                "DisasterRecoveryUrl": disaster_recovery_url,
+                "DisasterRecoveryMethod": disaster_recovery_method,
+                "TransferMode": transfer_mode,
+                "Secure": secure,
+                "CnamLookupEnabled": cnam_lookup_enabled,
+                "TransferCallerId": transfer_caller_id,
+            }
+        )
+
+        payload = await self._version.create_async(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return TrunkInstance(self._version, payload)
+
+    def stream(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> Iterator[TrunkInstance]:
+        """
+        Streams TrunkInstance records from the API as a generator stream.
+        This operation lazily loads records as efficiently as possible until the limit
+        is reached.
+        The results are returned as a generator, so this operation is memory efficient.
+
+        :param limit: Upper limit for the number of records to return. stream()
+                      guarantees to never return more than limit.  Default is no limit
+        :param page_size: Number of records to fetch per request, when not set will use
+                          the default value of 50 records.  If no page_size is defined
+                          but a limit is defined, stream() will attempt to read the
+                          limit with the most efficient page size, i.e. min(limit, 1000)
+
+        :returns: Generator that will yield up to limit results
+        """
+        limits = self._version.read_limits(limit, page_size)
+        page = self.page(page_size=limits["page_size"])
+
+        return self._version.stream(page, limits["limit"])
+
+    async def stream_async(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> AsyncIterator[TrunkInstance]:
+        """
+        Asynchronously streams TrunkInstance records from the API as a generator stream.
+        This operation lazily loads records as efficiently as possible until the limit
+        is reached.
+        The results are returned as a generator, so this operation is memory efficient.
+
+        :param limit: Upper limit for the number of records to return. stream()
+                      guarantees to never return more than limit.  Default is no limit
+        :param page_size: Number of records to fetch per request, when not set will use
+                          the default value of 50 records.  If no page_size is defined
+                          but a limit is defined, stream() will attempt to read the
+                          limit with the most efficient page size, i.e. min(limit, 1000)
+
+        :returns: Generator that will yield up to limit results
+        """
+        limits = self._version.read_limits(limit, page_size)
+        page = await self.page_async(page_size=limits["page_size"])
+
+        return self._version.stream_async(page, limits["limit"])
+
+    def list(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> List[TrunkInstance]:
+        """
+        Lists TrunkInstance records from the API as a list.
+        Unlike stream(), this operation is eager and will load `limit` records into
+        memory before returning.
+
+        :param limit: Upper limit for the number of records to return. list() guarantees
+                      never to return more than limit.  Default is no limit
+        :param page_size: Number of records to fetch per request, when not set will use
+                          the default value of 50 records.  If no page_size is defined
+                          but a limit is defined, list() will attempt to read the limit
+                          with the most efficient page size, i.e. min(limit, 1000)
+
+        :returns: list that will contain up to limit results
+        """
+        return list(
+            self.stream(
+                limit=limit,
+                page_size=page_size,
+            )
+        )
+
+    async def list_async(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> List[TrunkInstance]:
+        """
+        Asynchronously lists TrunkInstance records from the API as a list.
+        Unlike stream(), this operation is eager and will load `limit` records into
+        memory before returning.
+
+        :param limit: Upper limit for the number of records to return. list() guarantees
+                      never to return more than limit.  Default is no limit
+        :param page_size: Number of records to fetch per request, when not set will use
+                          the default value of 50 records.  If no page_size is defined
+                          but a limit is defined, list() will attempt to read the limit
+                          with the most efficient page size, i.e. min(limit, 1000)
+
+        :returns: list that will contain up to limit results
+        """
+        return [
+            record
+            async for record in await self.stream_async(
+                limit=limit,
+                page_size=page_size,
+            )
+        ]
+
+    def page(
+        self,
+        page_token: Union[str, object] = values.unset,
+        page_number: Union[int, object] = values.unset,
+        page_size: Union[int, object] = values.unset,
+    ) -> TrunkPage:
+        """
+        Retrieve a single page of TrunkInstance records from the API.
+        Request is executed immediately
+
+        :param page_token: PageToken provided by the API
+        :param page_number: Page Number, this value is simply for client state
+        :param page_size: Number of records to return, defaults to 50
+
+        :returns: Page of TrunkInstance
+        """
+        data = values.of(
+            {
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = self._version.page(method="GET", uri=self._uri, params=data)
+        return TrunkPage(self._version, response)
+
+    async def page_async(
+        self,
+        page_token: Union[str, object] = values.unset,
+        page_number: Union[int, object] = values.unset,
+        page_size: Union[int, object] = values.unset,
+    ) -> TrunkPage:
+        """
+        Asynchronously retrieve a single page of TrunkInstance records from the API.
+        Request is executed immediately
+
+        :param page_token: PageToken provided by the API
+        :param page_number: Page Number, this value is simply for client state
+        :param page_size: Number of records to return, defaults to 50
+
+        :returns: Page of TrunkInstance
+        """
+        data = values.of(
+            {
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = await self._version.page_async(
+            method="GET", uri=self._uri, params=data
+        )
+        return TrunkPage(self._version, response)
+
+    def get_page(self, target_url: str) -> TrunkPage:
+        """
+        Retrieve a specific page of TrunkInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of TrunkInstance
+        """
+        response = self._version.domain.twilio.request("GET", target_url)
+        return TrunkPage(self._version, response)
+
+    async def get_page_async(self, target_url: str) -> TrunkPage:
+        """
+        Asynchronously retrieve a specific page of TrunkInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of TrunkInstance
+        """
+        response = await self._version.domain.twilio.request_async("GET", target_url)
+        return TrunkPage(self._version, response)
+
+    def get(self, sid: str) -> TrunkContext:
+        """
+        Constructs a TrunkContext
+
+        :param sid: The unique string that we created to identify the OriginationUrl resource to update.
+        """
+        return TrunkContext(self._version, sid=sid)
+
+    def __call__(self, sid: str) -> TrunkContext:
+        """
+        Constructs a TrunkContext
+
+        :param sid: The unique string that we created to identify the OriginationUrl resource to update.
+        """
+        return TrunkContext(self._version, sid=sid)
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Trunking.V1.TrunkList>"

venv/lib/python3.11/site-packages/twilio/rest/trunking/v1/trunk/credential_list.py

@@ -0,0 +1,513 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Trunking
+    This is the public Twilio REST API.
+
+    NOTE: This class is auto generated by OpenAPI Generator.
+    https://openapi-generator.tech
+    Do not edit the class manually.
+"""
+
+
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Union, Iterator, AsyncIterator
+from twilio.base import deserialize, values
+from twilio.base.instance_context import InstanceContext
+from twilio.base.instance_resource import InstanceResource
+from twilio.base.list_resource import ListResource
+from twilio.base.version import Version
+from twilio.base.page import Page
+
+
+class CredentialListInstance(InstanceResource):
+
+    """
+    :ivar account_sid: The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the CredentialList resource.
+    :ivar sid: The unique string that we created to identify the CredentialList resource.
+    :ivar trunk_sid: The SID of the Trunk the credential list in associated with.
+    :ivar friendly_name: The string that you assigned to describe the resource.
+    :ivar date_created: The date and time in GMT when the resource was created specified in [RFC 2822](https://www.ietf.org/rfc/rfc2822.txt) format.
+    :ivar date_updated: The date and time in GMT when the resource was last updated specified in [RFC 2822](https://www.ietf.org/rfc/rfc2822.txt) format.
+    :ivar url: The absolute URL of the resource.
+    """
+
+    def __init__(
+        self,
+        version: Version,
+        payload: Dict[str, Any],
+        trunk_sid: str,
+        sid: Optional[str] = None,
+    ):
+        super().__init__(version)
+
+        self.account_sid: Optional[str] = payload.get("account_sid")
+        self.sid: Optional[str] = payload.get("sid")
+        self.trunk_sid: Optional[str] = payload.get("trunk_sid")
+        self.friendly_name: Optional[str] = payload.get("friendly_name")
+        self.date_created: Optional[datetime] = deserialize.iso8601_datetime(
+            payload.get("date_created")
+        )
+        self.date_updated: Optional[datetime] = deserialize.iso8601_datetime(
+            payload.get("date_updated")
+        )
+        self.url: Optional[str] = payload.get("url")
+
+        self._solution = {
+            "trunk_sid": trunk_sid,
+            "sid": sid or self.sid,
+        }
+        self._context: Optional[CredentialListContext] = None
+
+    @property
+    def _proxy(self) -> "CredentialListContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: CredentialListContext for this CredentialListInstance
+        """
+        if self._context is None:
+            self._context = CredentialListContext(
+                self._version,
+                trunk_sid=self._solution["trunk_sid"],
+                sid=self._solution["sid"],
+            )
+        return self._context
+
+    def delete(self) -> bool:
+        """
+        Deletes the CredentialListInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return self._proxy.delete()
+
+    async def delete_async(self) -> bool:
+        """
+        Asynchronous coroutine that deletes the CredentialListInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return await self._proxy.delete_async()
+
+    def fetch(self) -> "CredentialListInstance":
+        """
+        Fetch the CredentialListInstance
+
+
+        :returns: The fetched CredentialListInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "CredentialListInstance":
+        """
+        Asynchronous coroutine to fetch the CredentialListInstance
+
+
+        :returns: The fetched CredentialListInstance
+        """
+        return await self._proxy.fetch_async()
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        context = " ".join("{}={}".format(k, v) for k, v in self._solution.items())
+        return "<Twilio.Trunking.V1.CredentialListInstance {}>".format(context)
+
+
+class CredentialListContext(InstanceContext):
+    def __init__(self, version: Version, trunk_sid: str, sid: str):
+        """
+        Initialize the CredentialListContext
+
+        :param version: Version that contains the resource
+        :param trunk_sid: The SID of the Trunk from which to fetch the credential list.
+        :param sid: The unique string that we created to identify the CredentialList resource to fetch.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "trunk_sid": trunk_sid,
+            "sid": sid,
+        }
+        self._uri = "/Trunks/{trunk_sid}/CredentialLists/{sid}".format(**self._solution)
+
+    def delete(self) -> bool:
+        """
+        Deletes the CredentialListInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return self._version.delete(
+            method="DELETE",
+            uri=self._uri,
+        )
+
+    async def delete_async(self) -> bool:
+        """
+        Asynchronous coroutine that deletes the CredentialListInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return await self._version.delete_async(
+            method="DELETE",
+            uri=self._uri,
+        )
+
+    def fetch(self) -> CredentialListInstance:
+        """
+        Fetch the CredentialListInstance
+
+
+        :returns: The fetched CredentialListInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return CredentialListInstance(
+            self._version,
+            payload,
+            trunk_sid=self._solution["trunk_sid"],
+            sid=self._solution["sid"],
+        )
+
+    async def fetch_async(self) -> CredentialListInstance:
+        """
+        Asynchronous coroutine to fetch the CredentialListInstance
+
+
+        :returns: The fetched CredentialListInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return CredentialListInstance(
+            self._version,
+            payload,
+            trunk_sid=self._solution["trunk_sid"],
+            sid=self._solution["sid"],
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        context = " ".join("{}={}".format(k, v) for k, v in self._solution.items())
+        return "<Twilio.Trunking.V1.CredentialListContext {}>".format(context)
+
+
+class CredentialListPage(Page):
+    def get_instance(self, payload: Dict[str, Any]) -> CredentialListInstance:
+        """
+        Build an instance of CredentialListInstance
+
+        :param payload: Payload response from the API
+        """
+        return CredentialListInstance(
+            self._version, payload, trunk_sid=self._solution["trunk_sid"]
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Trunking.V1.CredentialListPage>"
+
+
+class CredentialListList(ListResource):
+    def __init__(self, version: Version, trunk_sid: str):
+        """
+        Initialize the CredentialListList
+
+        :param version: Version that contains the resource
+        :param trunk_sid: The SID of the Trunk from which to read the credential lists.
+
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "trunk_sid": trunk_sid,
+        }
+        self._uri = "/Trunks/{trunk_sid}/CredentialLists".format(**self._solution)
+
+    def create(self, credential_list_sid: str) -> CredentialListInstance:
+        """
+        Create the CredentialListInstance
+
+        :param credential_list_sid: The SID of the [Credential List](https://www.twilio.com/docs/voice/sip/api/sip-credentiallist-resource) that you want to associate with the trunk. Once associated, we will authenticate access to the trunk against this list.
+
+        :returns: The created CredentialListInstance
+        """
+        data = values.of(
+            {
+                "CredentialListSid": credential_list_sid,
+            }
+        )
+
+        payload = self._version.create(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return CredentialListInstance(
+            self._version, payload, trunk_sid=self._solution["trunk_sid"]
+        )
+
+    async def create_async(self, credential_list_sid: str) -> CredentialListInstance:
+        """
+        Asynchronously create the CredentialListInstance
+
+        :param credential_list_sid: The SID of the [Credential List](https://www.twilio.com/docs/voice/sip/api/sip-credentiallist-resource) that you want to associate with the trunk. Once associated, we will authenticate access to the trunk against this list.
+
+        :returns: The created CredentialListInstance
+        """
+        data = values.of(
+            {
+                "CredentialListSid": credential_list_sid,
+            }
+        )
+
+        payload = await self._version.create_async(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return CredentialListInstance(
+            self._version, payload, trunk_sid=self._solution["trunk_sid"]
+        )
+
+    def stream(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> Iterator[CredentialListInstance]:
+        """
+        Streams CredentialListInstance records from the API as a generator stream.
+        This operation lazily loads records as efficiently as possible until the limit
+        is reached.
+        The results are returned as a generator, so this operation is memory efficient.
+
+        :param limit: Upper limit for the number of records to return. stream()
+                      guarantees to never return more than limit.  Default is no limit
+        :param page_size: Number of records to fetch per request, when not set will use
+                          the default value of 50 records.  If no page_size is defined
+                          but a limit is defined, stream() will attempt to read the
+                          limit with the most efficient page size, i.e. min(limit, 1000)
+
+        :returns: Generator that will yield up to limit results
+        """
+        limits = self._version.read_limits(limit, page_size)
+        page = self.page(page_size=limits["page_size"])
+
+        return self._version.stream(page, limits["limit"])
+
+    async def stream_async(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> AsyncIterator[CredentialListInstance]:
+        """
+        Asynchronously streams CredentialListInstance records from the API as a generator stream.
+        This operation lazily loads records as efficiently as possible until the limit
+        is reached.
+        The results are returned as a generator, so this operation is memory efficient.
+
+        :param limit: Upper limit for the number of records to return. stream()
+                      guarantees to never return more than limit.  Default is no limit
+        :param page_size: Number of records to fetch per request, when not set will use
+                          the default value of 50 records.  If no page_size is defined
+                          but a limit is defined, stream() will attempt to read the
+                          limit with the most efficient page size, i.e. min(limit, 1000)
+
+        :returns: Generator that will yield up to limit results
+        """
+        limits = self._version.read_limits(limit, page_size)
+        page = await self.page_async(page_size=limits["page_size"])
+
+        return self._version.stream_async(page, limits["limit"])
+
+    def list(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> List[CredentialListInstance]:
+        """
+        Lists CredentialListInstance records from the API as a list.
+        Unlike stream(), this operation is eager and will load `limit` records into
+        memory before returning.
+
+        :param limit: Upper limit for the number of records to return. list() guarantees
+                      never to return more than limit.  Default is no limit
+        :param page_size: Number of records to fetch per request, when not set will use
+                          the default value of 50 records.  If no page_size is defined
+                          but a limit is defined, list() will attempt to read the limit
+                          with the most efficient page size, i.e. min(limit, 1000)
+
+        :returns: list that will contain up to limit results
+        """
+        return list(
+            self.stream(
+                limit=limit,
+                page_size=page_size,
+            )
+        )
+
+    async def list_async(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> List[CredentialListInstance]:
+        """
+        Asynchronously lists CredentialListInstance records from the API as a list.
+        Unlike stream(), this operation is eager and will load `limit` records into
+        memory before returning.
+
+        :param limit: Upper limit for the number of records to return. list() guarantees
+                      never to return more than limit.  Default is no limit
+        :param page_size: Number of records to fetch per request, when not set will use
+                          the default value of 50 records.  If no page_size is defined
+                          but a limit is defined, list() will attempt to read the limit
+                          with the most efficient page size, i.e. min(limit, 1000)
+
+        :returns: list that will contain up to limit results
+        """
+        return [
+            record
+            async for record in await self.stream_async(
+                limit=limit,
+                page_size=page_size,
+            )
+        ]
+
+    def page(
+        self,
+        page_token: Union[str, object] = values.unset,
+        page_number: Union[int, object] = values.unset,
+        page_size: Union[int, object] = values.unset,
+    ) -> CredentialListPage:
+        """
+        Retrieve a single page of CredentialListInstance records from the API.
+        Request is executed immediately
+
+        :param page_token: PageToken provided by the API
+        :param page_number: Page Number, this value is simply for client state
+        :param page_size: Number of records to return, defaults to 50
+
+        :returns: Page of CredentialListInstance
+        """
+        data = values.of(
+            {
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = self._version.page(method="GET", uri=self._uri, params=data)
+        return CredentialListPage(self._version, response, self._solution)
+
+    async def page_async(
+        self,
+        page_token: Union[str, object] = values.unset,
+        page_number: Union[int, object] = values.unset,
+        page_size: Union[int, object] = values.unset,
+    ) -> CredentialListPage:
+        """
+        Asynchronously retrieve a single page of CredentialListInstance records from the API.
+        Request is executed immediately
+
+        :param page_token: PageToken provided by the API
+        :param page_number: Page Number, this value is simply for client state
+        :param page_size: Number of records to return, defaults to 50
+
+        :returns: Page of CredentialListInstance
+        """
+        data = values.of(
+            {
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = await self._version.page_async(
+            method="GET", uri=self._uri, params=data
+        )
+        return CredentialListPage(self._version, response, self._solution)
+
+    def get_page(self, target_url: str) -> CredentialListPage:
+        """
+        Retrieve a specific page of CredentialListInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of CredentialListInstance
+        """
+        response = self._version.domain.twilio.request("GET", target_url)
+        return CredentialListPage(self._version, response, self._solution)
+
+    async def get_page_async(self, target_url: str) -> CredentialListPage:
+        """
+        Asynchronously retrieve a specific page of CredentialListInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of CredentialListInstance
+        """
+        response = await self._version.domain.twilio.request_async("GET", target_url)
+        return CredentialListPage(self._version, response, self._solution)
+
+    def get(self, sid: str) -> CredentialListContext:
+        """
+        Constructs a CredentialListContext
+
+        :param sid: The unique string that we created to identify the CredentialList resource to fetch.
+        """
+        return CredentialListContext(
+            self._version, trunk_sid=self._solution["trunk_sid"], sid=sid
+        )
+
+    def __call__(self, sid: str) -> CredentialListContext:
+        """
+        Constructs a CredentialListContext
+
+        :param sid: The unique string that we created to identify the CredentialList resource to fetch.
+        """
+        return CredentialListContext(
+            self._version, trunk_sid=self._solution["trunk_sid"], sid=sid
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Trunking.V1.CredentialListList>"

venv/lib/python3.11/site-packages/twilio/rest/trunking/v1/trunk/ip_access_control_list.py

@@ -0,0 +1,517 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Trunking
+    This is the public Twilio REST API.
+
+    NOTE: This class is auto generated by OpenAPI Generator.
+    https://openapi-generator.tech
+    Do not edit the class manually.
+"""
+
+
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Union, Iterator, AsyncIterator
+from twilio.base import deserialize, values
+from twilio.base.instance_context import InstanceContext
+from twilio.base.instance_resource import InstanceResource
+from twilio.base.list_resource import ListResource
+from twilio.base.version import Version
+from twilio.base.page import Page
+
+
+class IpAccessControlListInstance(InstanceResource):
+
+    """
+    :ivar account_sid: The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the IpAccessControlList resource.
+    :ivar sid: The unique string that we created to identify the IpAccessControlList resource.
+    :ivar trunk_sid: The SID of the Trunk the resource is associated with.
+    :ivar friendly_name: The string that you assigned to describe the resource.
+    :ivar date_created: The date and time in GMT when the resource was created specified in [RFC 2822](https://www.ietf.org/rfc/rfc2822.txt) format.
+    :ivar date_updated: The date and time in GMT when the resource was last updated specified in [RFC 2822](https://www.ietf.org/rfc/rfc2822.txt) format.
+    :ivar url: The absolute URL of the resource.
+    """
+
+    def __init__(
+        self,
+        version: Version,
+        payload: Dict[str, Any],
+        trunk_sid: str,
+        sid: Optional[str] = None,
+    ):
+        super().__init__(version)
+
+        self.account_sid: Optional[str] = payload.get("account_sid")
+        self.sid: Optional[str] = payload.get("sid")
+        self.trunk_sid: Optional[str] = payload.get("trunk_sid")
+        self.friendly_name: Optional[str] = payload.get("friendly_name")
+        self.date_created: Optional[datetime] = deserialize.iso8601_datetime(
+            payload.get("date_created")
+        )
+        self.date_updated: Optional[datetime] = deserialize.iso8601_datetime(
+            payload.get("date_updated")
+        )
+        self.url: Optional[str] = payload.get("url")
+
+        self._solution = {
+            "trunk_sid": trunk_sid,
+            "sid": sid or self.sid,
+        }
+        self._context: Optional[IpAccessControlListContext] = None
+
+    @property
+    def _proxy(self) -> "IpAccessControlListContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: IpAccessControlListContext for this IpAccessControlListInstance
+        """
+        if self._context is None:
+            self._context = IpAccessControlListContext(
+                self._version,
+                trunk_sid=self._solution["trunk_sid"],
+                sid=self._solution["sid"],
+            )
+        return self._context
+
+    def delete(self) -> bool:
+        """
+        Deletes the IpAccessControlListInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return self._proxy.delete()
+
+    async def delete_async(self) -> bool:
+        """
+        Asynchronous coroutine that deletes the IpAccessControlListInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return await self._proxy.delete_async()
+
+    def fetch(self) -> "IpAccessControlListInstance":
+        """
+        Fetch the IpAccessControlListInstance
+
+
+        :returns: The fetched IpAccessControlListInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "IpAccessControlListInstance":
+        """
+        Asynchronous coroutine to fetch the IpAccessControlListInstance
+
+
+        :returns: The fetched IpAccessControlListInstance
+        """
+        return await self._proxy.fetch_async()
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        context = " ".join("{}={}".format(k, v) for k, v in self._solution.items())
+        return "<Twilio.Trunking.V1.IpAccessControlListInstance {}>".format(context)
+
+
+class IpAccessControlListContext(InstanceContext):
+    def __init__(self, version: Version, trunk_sid: str, sid: str):
+        """
+        Initialize the IpAccessControlListContext
+
+        :param version: Version that contains the resource
+        :param trunk_sid: The SID of the Trunk from which to fetch the IP Access Control List.
+        :param sid: The unique string that we created to identify the IpAccessControlList resource to fetch.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "trunk_sid": trunk_sid,
+            "sid": sid,
+        }
+        self._uri = "/Trunks/{trunk_sid}/IpAccessControlLists/{sid}".format(
+            **self._solution
+        )
+
+    def delete(self) -> bool:
+        """
+        Deletes the IpAccessControlListInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return self._version.delete(
+            method="DELETE",
+            uri=self._uri,
+        )
+
+    async def delete_async(self) -> bool:
+        """
+        Asynchronous coroutine that deletes the IpAccessControlListInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return await self._version.delete_async(
+            method="DELETE",
+            uri=self._uri,
+        )
+
+    def fetch(self) -> IpAccessControlListInstance:
+        """
+        Fetch the IpAccessControlListInstance
+
+
+        :returns: The fetched IpAccessControlListInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return IpAccessControlListInstance(
+            self._version,
+            payload,
+            trunk_sid=self._solution["trunk_sid"],
+            sid=self._solution["sid"],
+        )
+
+    async def fetch_async(self) -> IpAccessControlListInstance:
+        """
+        Asynchronous coroutine to fetch the IpAccessControlListInstance
+
+
+        :returns: The fetched IpAccessControlListInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return IpAccessControlListInstance(
+            self._version,
+            payload,
+            trunk_sid=self._solution["trunk_sid"],
+            sid=self._solution["sid"],
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        context = " ".join("{}={}".format(k, v) for k, v in self._solution.items())
+        return "<Twilio.Trunking.V1.IpAccessControlListContext {}>".format(context)
+
+
+class IpAccessControlListPage(Page):
+    def get_instance(self, payload: Dict[str, Any]) -> IpAccessControlListInstance:
+        """
+        Build an instance of IpAccessControlListInstance
+
+        :param payload: Payload response from the API
+        """
+        return IpAccessControlListInstance(
+            self._version, payload, trunk_sid=self._solution["trunk_sid"]
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Trunking.V1.IpAccessControlListPage>"
+
+
+class IpAccessControlListList(ListResource):
+    def __init__(self, version: Version, trunk_sid: str):
+        """
+        Initialize the IpAccessControlListList
+
+        :param version: Version that contains the resource
+        :param trunk_sid: The SID of the Trunk from which to read the IP Access Control Lists.
+
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "trunk_sid": trunk_sid,
+        }
+        self._uri = "/Trunks/{trunk_sid}/IpAccessControlLists".format(**self._solution)
+
+    def create(self, ip_access_control_list_sid: str) -> IpAccessControlListInstance:
+        """
+        Create the IpAccessControlListInstance
+
+        :param ip_access_control_list_sid: The SID of the [IP Access Control List](https://www.twilio.com/docs/voice/sip/api/sip-ipaccesscontrollist-resource) that you want to associate with the trunk.
+
+        :returns: The created IpAccessControlListInstance
+        """
+        data = values.of(
+            {
+                "IpAccessControlListSid": ip_access_control_list_sid,
+            }
+        )
+
+        payload = self._version.create(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return IpAccessControlListInstance(
+            self._version, payload, trunk_sid=self._solution["trunk_sid"]
+        )
+
+    async def create_async(
+        self, ip_access_control_list_sid: str
+    ) -> IpAccessControlListInstance:
+        """
+        Asynchronously create the IpAccessControlListInstance
+
+        :param ip_access_control_list_sid: The SID of the [IP Access Control List](https://www.twilio.com/docs/voice/sip/api/sip-ipaccesscontrollist-resource) that you want to associate with the trunk.
+
+        :returns: The created IpAccessControlListInstance
+        """
+        data = values.of(
+            {
+                "IpAccessControlListSid": ip_access_control_list_sid,
+            }
+        )
+
+        payload = await self._version.create_async(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return IpAccessControlListInstance(
+            self._version, payload, trunk_sid=self._solution["trunk_sid"]
+        )
+
+    def stream(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> Iterator[IpAccessControlListInstance]:
+        """
+        Streams IpAccessControlListInstance records from the API as a generator stream.
+        This operation lazily loads records as efficiently as possible until the limit
+        is reached.
+        The results are returned as a generator, so this operation is memory efficient.
+
+        :param limit: Upper limit for the number of records to return. stream()
+                      guarantees to never return more than limit.  Default is no limit
+        :param page_size: Number of records to fetch per request, when not set will use
+                          the default value of 50 records.  If no page_size is defined
+                          but a limit is defined, stream() will attempt to read the
+                          limit with the most efficient page size, i.e. min(limit, 1000)
+
+        :returns: Generator that will yield up to limit results
+        """
+        limits = self._version.read_limits(limit, page_size)
+        page = self.page(page_size=limits["page_size"])
+
+        return self._version.stream(page, limits["limit"])
+
+    async def stream_async(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> AsyncIterator[IpAccessControlListInstance]:
+        """
+        Asynchronously streams IpAccessControlListInstance records from the API as a generator stream.
+        This operation lazily loads records as efficiently as possible until the limit
+        is reached.
+        The results are returned as a generator, so this operation is memory efficient.
+
+        :param limit: Upper limit for the number of records to return. stream()
+                      guarantees to never return more than limit.  Default is no limit
+        :param page_size: Number of records to fetch per request, when not set will use
+                          the default value of 50 records.  If no page_size is defined
+                          but a limit is defined, stream() will attempt to read the
+                          limit with the most efficient page size, i.e. min(limit, 1000)
+
+        :returns: Generator that will yield up to limit results
+        """
+        limits = self._version.read_limits(limit, page_size)
+        page = await self.page_async(page_size=limits["page_size"])
+
+        return self._version.stream_async(page, limits["limit"])
+
+    def list(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> List[IpAccessControlListInstance]:
+        """
+        Lists IpAccessControlListInstance records from the API as a list.
+        Unlike stream(), this operation is eager and will load `limit` records into
+        memory before returning.
+
+        :param limit: Upper limit for the number of records to return. list() guarantees
+                      never to return more than limit.  Default is no limit
+        :param page_size: Number of records to fetch per request, when not set will use
+                          the default value of 50 records.  If no page_size is defined
+                          but a limit is defined, list() will attempt to read the limit
+                          with the most efficient page size, i.e. min(limit, 1000)
+
+        :returns: list that will contain up to limit results
+        """
+        return list(
+            self.stream(
+                limit=limit,
+                page_size=page_size,
+            )
+        )
+
+    async def list_async(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> List[IpAccessControlListInstance]:
+        """
+        Asynchronously lists IpAccessControlListInstance records from the API as a list.
+        Unlike stream(), this operation is eager and will load `limit` records into
+        memory before returning.
+
+        :param limit: Upper limit for the number of records to return. list() guarantees
+                      never to return more than limit.  Default is no limit
+        :param page_size: Number of records to fetch per request, when not set will use
+                          the default value of 50 records.  If no page_size is defined
+                          but a limit is defined, list() will attempt to read the limit
+                          with the most efficient page size, i.e. min(limit, 1000)
+
+        :returns: list that will contain up to limit results
+        """
+        return [
+            record
+            async for record in await self.stream_async(
+                limit=limit,
+                page_size=page_size,
+            )
+        ]
+
+    def page(
+        self,
+        page_token: Union[str, object] = values.unset,
+        page_number: Union[int, object] = values.unset,
+        page_size: Union[int, object] = values.unset,
+    ) -> IpAccessControlListPage:
+        """
+        Retrieve a single page of IpAccessControlListInstance records from the API.
+        Request is executed immediately
+
+        :param page_token: PageToken provided by the API
+        :param page_number: Page Number, this value is simply for client state
+        :param page_size: Number of records to return, defaults to 50
+
+        :returns: Page of IpAccessControlListInstance
+        """
+        data = values.of(
+            {
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = self._version.page(method="GET", uri=self._uri, params=data)
+        return IpAccessControlListPage(self._version, response, self._solution)
+
+    async def page_async(
+        self,
+        page_token: Union[str, object] = values.unset,
+        page_number: Union[int, object] = values.unset,
+        page_size: Union[int, object] = values.unset,
+    ) -> IpAccessControlListPage:
+        """
+        Asynchronously retrieve a single page of IpAccessControlListInstance records from the API.
+        Request is executed immediately
+
+        :param page_token: PageToken provided by the API
+        :param page_number: Page Number, this value is simply for client state
+        :param page_size: Number of records to return, defaults to 50
+
+        :returns: Page of IpAccessControlListInstance
+        """
+        data = values.of(
+            {
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = await self._version.page_async(
+            method="GET", uri=self._uri, params=data
+        )
+        return IpAccessControlListPage(self._version, response, self._solution)
+
+    def get_page(self, target_url: str) -> IpAccessControlListPage:
+        """
+        Retrieve a specific page of IpAccessControlListInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of IpAccessControlListInstance
+        """
+        response = self._version.domain.twilio.request("GET", target_url)
+        return IpAccessControlListPage(self._version, response, self._solution)
+
+    async def get_page_async(self, target_url: str) -> IpAccessControlListPage:
+        """
+        Asynchronously retrieve a specific page of IpAccessControlListInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of IpAccessControlListInstance
+        """
+        response = await self._version.domain.twilio.request_async("GET", target_url)
+        return IpAccessControlListPage(self._version, response, self._solution)
+
+    def get(self, sid: str) -> IpAccessControlListContext:
+        """
+        Constructs a IpAccessControlListContext
+
+        :param sid: The unique string that we created to identify the IpAccessControlList resource to fetch.
+        """
+        return IpAccessControlListContext(
+            self._version, trunk_sid=self._solution["trunk_sid"], sid=sid
+        )
+
+    def __call__(self, sid: str) -> IpAccessControlListContext:
+        """
+        Constructs a IpAccessControlListContext
+
+        :param sid: The unique string that we created to identify the IpAccessControlList resource to fetch.
+        """
+        return IpAccessControlListContext(
+            self._version, trunk_sid=self._solution["trunk_sid"], sid=sid
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Trunking.V1.IpAccessControlListList>"

venv/lib/python3.11/site-packages/twilio/rest/trunking/v1/trunk/origination_url.py

@@ -0,0 +1,689 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Trunking
+    This is the public Twilio REST API.
+
+    NOTE: This class is auto generated by OpenAPI Generator.
+    https://openapi-generator.tech
+    Do not edit the class manually.
+"""
+
+
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Union, Iterator, AsyncIterator
+from twilio.base import deserialize, values
+from twilio.base.instance_context import InstanceContext
+from twilio.base.instance_resource import InstanceResource
+from twilio.base.list_resource import ListResource
+from twilio.base.version import Version
+from twilio.base.page import Page
+
+
+class OriginationUrlInstance(InstanceResource):
+
+    """
+    :ivar account_sid: The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the OriginationUrl resource.
+    :ivar sid: The unique string that we created to identify the OriginationUrl resource.
+    :ivar trunk_sid: The SID of the Trunk that owns the Origination URL.
+    :ivar weight: The value that determines the relative share of the load the URI should receive compared to other URIs with the same priority. Can be an integer from 1 to 65535, inclusive, and the default is 10. URLs with higher values receive more load than those with lower ones with the same priority.
+    :ivar enabled: Whether the URL is enabled. The default is `true`.
+    :ivar sip_url: The SIP address you want Twilio to route your Origination calls to. This must be a `sip:` schema.
+    :ivar friendly_name: The string that you assigned to describe the resource.
+    :ivar priority: The relative importance of the URI. Can be an integer from 0 to 65535, inclusive, and the default is 10. The lowest number represents the most important URI.
+    :ivar date_created: The date and time in GMT when the resource was created specified in [RFC 2822](https://www.ietf.org/rfc/rfc2822.txt) format.
+    :ivar date_updated: The date and time in GMT when the resource was last updated specified in [RFC 2822](https://www.ietf.org/rfc/rfc2822.txt) format.
+    :ivar url: The absolute URL of the resource.
+    """
+
+    def __init__(
+        self,
+        version: Version,
+        payload: Dict[str, Any],
+        trunk_sid: str,
+        sid: Optional[str] = None,
+    ):
+        super().__init__(version)
+
+        self.account_sid: Optional[str] = payload.get("account_sid")
+        self.sid: Optional[str] = payload.get("sid")
+        self.trunk_sid: Optional[str] = payload.get("trunk_sid")
+        self.weight: Optional[int] = deserialize.integer(payload.get("weight"))
+        self.enabled: Optional[bool] = payload.get("enabled")
+        self.sip_url: Optional[str] = payload.get("sip_url")
+        self.friendly_name: Optional[str] = payload.get("friendly_name")
+        self.priority: Optional[int] = deserialize.integer(payload.get("priority"))
+        self.date_created: Optional[datetime] = deserialize.iso8601_datetime(
+            payload.get("date_created")
+        )
+        self.date_updated: Optional[datetime] = deserialize.iso8601_datetime(
+            payload.get("date_updated")
+        )
+        self.url: Optional[str] = payload.get("url")
+
+        self._solution = {
+            "trunk_sid": trunk_sid,
+            "sid": sid or self.sid,
+        }
+        self._context: Optional[OriginationUrlContext] = None
+
+    @property
+    def _proxy(self) -> "OriginationUrlContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: OriginationUrlContext for this OriginationUrlInstance
+        """
+        if self._context is None:
+            self._context = OriginationUrlContext(
+                self._version,
+                trunk_sid=self._solution["trunk_sid"],
+                sid=self._solution["sid"],
+            )
+        return self._context
+
+    def delete(self) -> bool:
+        """
+        Deletes the OriginationUrlInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return self._proxy.delete()
+
+    async def delete_async(self) -> bool:
+        """
+        Asynchronous coroutine that deletes the OriginationUrlInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return await self._proxy.delete_async()
+
+    def fetch(self) -> "OriginationUrlInstance":
+        """
+        Fetch the OriginationUrlInstance
+
+
+        :returns: The fetched OriginationUrlInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "OriginationUrlInstance":
+        """
+        Asynchronous coroutine to fetch the OriginationUrlInstance
+
+
+        :returns: The fetched OriginationUrlInstance
+        """
+        return await self._proxy.fetch_async()
+
+    def update(
+        self,
+        weight: Union[int, object] = values.unset,
+        priority: Union[int, object] = values.unset,
+        enabled: Union[bool, object] = values.unset,
+        friendly_name: Union[str, object] = values.unset,
+        sip_url: Union[str, object] = values.unset,
+    ) -> "OriginationUrlInstance":
+        """
+        Update the OriginationUrlInstance
+
+        :param weight: The value that determines the relative share of the load the URI should receive compared to other URIs with the same priority. Can be an integer from 1 to 65535, inclusive, and the default is 10. URLs with higher values receive more load than those with lower ones with the same priority.
+        :param priority: The relative importance of the URI. Can be an integer from 0 to 65535, inclusive, and the default is 10. The lowest number represents the most important URI.
+        :param enabled: Whether the URL is enabled. The default is `true`.
+        :param friendly_name: A descriptive string that you create to describe the resource. It can be up to 64 characters long.
+        :param sip_url: The SIP address you want Twilio to route your Origination calls to. This must be a `sip:` schema. `sips` is NOT supported.
+
+        :returns: The updated OriginationUrlInstance
+        """
+        return self._proxy.update(
+            weight=weight,
+            priority=priority,
+            enabled=enabled,
+            friendly_name=friendly_name,
+            sip_url=sip_url,
+        )
+
+    async def update_async(
+        self,
+        weight: Union[int, object] = values.unset,
+        priority: Union[int, object] = values.unset,
+        enabled: Union[bool, object] = values.unset,
+        friendly_name: Union[str, object] = values.unset,
+        sip_url: Union[str, object] = values.unset,
+    ) -> "OriginationUrlInstance":
+        """
+        Asynchronous coroutine to update the OriginationUrlInstance
+
+        :param weight: The value that determines the relative share of the load the URI should receive compared to other URIs with the same priority. Can be an integer from 1 to 65535, inclusive, and the default is 10. URLs with higher values receive more load than those with lower ones with the same priority.
+        :param priority: The relative importance of the URI. Can be an integer from 0 to 65535, inclusive, and the default is 10. The lowest number represents the most important URI.
+        :param enabled: Whether the URL is enabled. The default is `true`.
+        :param friendly_name: A descriptive string that you create to describe the resource. It can be up to 64 characters long.
+        :param sip_url: The SIP address you want Twilio to route your Origination calls to. This must be a `sip:` schema. `sips` is NOT supported.
+
+        :returns: The updated OriginationUrlInstance
+        """
+        return await self._proxy.update_async(
+            weight=weight,
+            priority=priority,
+            enabled=enabled,
+            friendly_name=friendly_name,
+            sip_url=sip_url,
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        context = " ".join("{}={}".format(k, v) for k, v in self._solution.items())
+        return "<Twilio.Trunking.V1.OriginationUrlInstance {}>".format(context)
+
+
+class OriginationUrlContext(InstanceContext):
+    def __init__(self, version: Version, trunk_sid: str, sid: str):
+        """
+        Initialize the OriginationUrlContext
+
+        :param version: Version that contains the resource
+        :param trunk_sid: The SID of the Trunk from which to update the OriginationUrl.
+        :param sid: The unique string that we created to identify the OriginationUrl resource to update.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "trunk_sid": trunk_sid,
+            "sid": sid,
+        }
+        self._uri = "/Trunks/{trunk_sid}/OriginationUrls/{sid}".format(**self._solution)
+
+    def delete(self) -> bool:
+        """
+        Deletes the OriginationUrlInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return self._version.delete(
+            method="DELETE",
+            uri=self._uri,
+        )
+
+    async def delete_async(self) -> bool:
+        """
+        Asynchronous coroutine that deletes the OriginationUrlInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return await self._version.delete_async(
+            method="DELETE",
+            uri=self._uri,
+        )
+
+    def fetch(self) -> OriginationUrlInstance:
+        """
+        Fetch the OriginationUrlInstance
+
+
+        :returns: The fetched OriginationUrlInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return OriginationUrlInstance(
+            self._version,
+            payload,
+            trunk_sid=self._solution["trunk_sid"],
+            sid=self._solution["sid"],
+        )
+
+    async def fetch_async(self) -> OriginationUrlInstance:
+        """
+        Asynchronous coroutine to fetch the OriginationUrlInstance
+
+
+        :returns: The fetched OriginationUrlInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return OriginationUrlInstance(
+            self._version,
+            payload,
+            trunk_sid=self._solution["trunk_sid"],
+            sid=self._solution["sid"],
+        )
+
+    def update(
+        self,
+        weight: Union[int, object] = values.unset,
+        priority: Union[int, object] = values.unset,
+        enabled: Union[bool, object] = values.unset,
+        friendly_name: Union[str, object] = values.unset,
+        sip_url: Union[str, object] = values.unset,
+    ) -> OriginationUrlInstance:
+        """
+        Update the OriginationUrlInstance
+
+        :param weight: The value that determines the relative share of the load the URI should receive compared to other URIs with the same priority. Can be an integer from 1 to 65535, inclusive, and the default is 10. URLs with higher values receive more load than those with lower ones with the same priority.
+        :param priority: The relative importance of the URI. Can be an integer from 0 to 65535, inclusive, and the default is 10. The lowest number represents the most important URI.
+        :param enabled: Whether the URL is enabled. The default is `true`.
+        :param friendly_name: A descriptive string that you create to describe the resource. It can be up to 64 characters long.
+        :param sip_url: The SIP address you want Twilio to route your Origination calls to. This must be a `sip:` schema. `sips` is NOT supported.
+
+        :returns: The updated OriginationUrlInstance
+        """
+        data = values.of(
+            {
+                "Weight": weight,
+                "Priority": priority,
+                "Enabled": enabled,
+                "FriendlyName": friendly_name,
+                "SipUrl": sip_url,
+            }
+        )
+
+        payload = self._version.update(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return OriginationUrlInstance(
+            self._version,
+            payload,
+            trunk_sid=self._solution["trunk_sid"],
+            sid=self._solution["sid"],
+        )
+
+    async def update_async(
+        self,
+        weight: Union[int, object] = values.unset,
+        priority: Union[int, object] = values.unset,
+        enabled: Union[bool, object] = values.unset,
+        friendly_name: Union[str, object] = values.unset,
+        sip_url: Union[str, object] = values.unset,
+    ) -> OriginationUrlInstance:
+        """
+        Asynchronous coroutine to update the OriginationUrlInstance
+
+        :param weight: The value that determines the relative share of the load the URI should receive compared to other URIs with the same priority. Can be an integer from 1 to 65535, inclusive, and the default is 10. URLs with higher values receive more load than those with lower ones with the same priority.
+        :param priority: The relative importance of the URI. Can be an integer from 0 to 65535, inclusive, and the default is 10. The lowest number represents the most important URI.
+        :param enabled: Whether the URL is enabled. The default is `true`.
+        :param friendly_name: A descriptive string that you create to describe the resource. It can be up to 64 characters long.
+        :param sip_url: The SIP address you want Twilio to route your Origination calls to. This must be a `sip:` schema. `sips` is NOT supported.
+
+        :returns: The updated OriginationUrlInstance
+        """
+        data = values.of(
+            {
+                "Weight": weight,
+                "Priority": priority,
+                "Enabled": enabled,
+                "FriendlyName": friendly_name,
+                "SipUrl": sip_url,
+            }
+        )
+
+        payload = await self._version.update_async(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return OriginationUrlInstance(
+            self._version,
+            payload,
+            trunk_sid=self._solution["trunk_sid"],
+            sid=self._solution["sid"],
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        context = " ".join("{}={}".format(k, v) for k, v in self._solution.items())
+        return "<Twilio.Trunking.V1.OriginationUrlContext {}>".format(context)
+
+
+class OriginationUrlPage(Page):
+    def get_instance(self, payload: Dict[str, Any]) -> OriginationUrlInstance:
+        """
+        Build an instance of OriginationUrlInstance
+
+        :param payload: Payload response from the API
+        """
+        return OriginationUrlInstance(
+            self._version, payload, trunk_sid=self._solution["trunk_sid"]
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Trunking.V1.OriginationUrlPage>"
+
+
+class OriginationUrlList(ListResource):
+    def __init__(self, version: Version, trunk_sid: str):
+        """
+        Initialize the OriginationUrlList
+
+        :param version: Version that contains the resource
+        :param trunk_sid: The SID of the Trunk from which to read the OriginationUrl.
+
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "trunk_sid": trunk_sid,
+        }
+        self._uri = "/Trunks/{trunk_sid}/OriginationUrls".format(**self._solution)
+
+    def create(
+        self,
+        weight: int,
+        priority: int,
+        enabled: bool,
+        friendly_name: str,
+        sip_url: str,
+    ) -> OriginationUrlInstance:
+        """
+        Create the OriginationUrlInstance
+
+        :param weight: The value that determines the relative share of the load the URI should receive compared to other URIs with the same priority. Can be an integer from 1 to 65535, inclusive, and the default is 10. URLs with higher values receive more load than those with lower ones with the same priority.
+        :param priority: The relative importance of the URI. Can be an integer from 0 to 65535, inclusive, and the default is 10. The lowest number represents the most important URI.
+        :param enabled: Whether the URL is enabled. The default is `true`.
+        :param friendly_name: A descriptive string that you create to describe the resource. It can be up to 64 characters long.
+        :param sip_url: The SIP address you want Twilio to route your Origination calls to. This must be a `sip:` schema.
+
+        :returns: The created OriginationUrlInstance
+        """
+        data = values.of(
+            {
+                "Weight": weight,
+                "Priority": priority,
+                "Enabled": enabled,
+                "FriendlyName": friendly_name,
+                "SipUrl": sip_url,
+            }
+        )
+
+        payload = self._version.create(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return OriginationUrlInstance(
+            self._version, payload, trunk_sid=self._solution["trunk_sid"]
+        )
+
+    async def create_async(
+        self,
+        weight: int,
+        priority: int,
+        enabled: bool,
+        friendly_name: str,
+        sip_url: str,
+    ) -> OriginationUrlInstance:
+        """
+        Asynchronously create the OriginationUrlInstance
+
+        :param weight: The value that determines the relative share of the load the URI should receive compared to other URIs with the same priority. Can be an integer from 1 to 65535, inclusive, and the default is 10. URLs with higher values receive more load than those with lower ones with the same priority.
+        :param priority: The relative importance of the URI. Can be an integer from 0 to 65535, inclusive, and the default is 10. The lowest number represents the most important URI.
+        :param enabled: Whether the URL is enabled. The default is `true`.
+        :param friendly_name: A descriptive string that you create to describe the resource. It can be up to 64 characters long.
+        :param sip_url: The SIP address you want Twilio to route your Origination calls to. This must be a `sip:` schema.
+
+        :returns: The created OriginationUrlInstance
+        """
+        data = values.of(
+            {
+                "Weight": weight,
+                "Priority": priority,
+                "Enabled": enabled,
+                "FriendlyName": friendly_name,
+                "SipUrl": sip_url,
+            }
+        )
+
+        payload = await self._version.create_async(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return OriginationUrlInstance(
+            self._version, payload, trunk_sid=self._solution["trunk_sid"]
+        )
+
+    def stream(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> Iterator[OriginationUrlInstance]:
+        """
+        Streams OriginationUrlInstance records from the API as a generator stream.
+        This operation lazily loads records as efficiently as possible until the limit
+        is reached.
+        The results are returned as a generator, so this operation is memory efficient.
+
+        :param limit: Upper limit for the number of records to return. stream()
+                      guarantees to never return more than limit.  Default is no limit
+        :param page_size: Number of records to fetch per request, when not set will use
+                          the default value of 50 records.  If no page_size is defined
+                          but a limit is defined, stream() will attempt to read the
+                          limit with the most efficient page size, i.e. min(limit, 1000)
+
+        :returns: Generator that will yield up to limit results
+        """
+        limits = self._version.read_limits(limit, page_size)
+        page = self.page(page_size=limits["page_size"])
+
+        return self._version.stream(page, limits["limit"])
+
+    async def stream_async(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> AsyncIterator[OriginationUrlInstance]:
+        """
+        Asynchronously streams OriginationUrlInstance records from the API as a generator stream.
+        This operation lazily loads records as efficiently as possible until the limit
+        is reached.
+        The results are returned as a generator, so this operation is memory efficient.
+
+        :param limit: Upper limit for the number of records to return. stream()
+                      guarantees to never return more than limit.  Default is no limit
+        :param page_size: Number of records to fetch per request, when not set will use
+                          the default value of 50 records.  If no page_size is defined
+                          but a limit is defined, stream() will attempt to read the
+                          limit with the most efficient page size, i.e. min(limit, 1000)
+
+        :returns: Generator that will yield up to limit results
+        """
+        limits = self._version.read_limits(limit, page_size)
+        page = await self.page_async(page_size=limits["page_size"])
+
+        return self._version.stream_async(page, limits["limit"])
+
+    def list(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> List[OriginationUrlInstance]:
+        """
+        Lists OriginationUrlInstance records from the API as a list.
+        Unlike stream(), this operation is eager and will load `limit` records into
+        memory before returning.
+
+        :param limit: Upper limit for the number of records to return. list() guarantees
+                      never to return more than limit.  Default is no limit
+        :param page_size: Number of records to fetch per request, when not set will use
+                          the default value of 50 records.  If no page_size is defined
+                          but a limit is defined, list() will attempt to read the limit
+                          with the most efficient page size, i.e. min(limit, 1000)
+
+        :returns: list that will contain up to limit results
+        """
+        return list(
+            self.stream(
+                limit=limit,
+                page_size=page_size,
+            )
+        )
+
+    async def list_async(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> List[OriginationUrlInstance]:
+        """
+        Asynchronously lists OriginationUrlInstance records from the API as a list.
+        Unlike stream(), this operation is eager and will load `limit` records into
+        memory before returning.
+
+        :param limit: Upper limit for the number of records to return. list() guarantees
+                      never to return more than limit.  Default is no limit
+        :param page_size: Number of records to fetch per request, when not set will use
+                          the default value of 50 records.  If no page_size is defined
+                          but a limit is defined, list() will attempt to read the limit
+                          with the most efficient page size, i.e. min(limit, 1000)
+
+        :returns: list that will contain up to limit results
+        """
+        return [
+            record
+            async for record in await self.stream_async(
+                limit=limit,
+                page_size=page_size,
+            )
+        ]
+
+    def page(
+        self,
+        page_token: Union[str, object] = values.unset,
+        page_number: Union[int, object] = values.unset,
+        page_size: Union[int, object] = values.unset,
+    ) -> OriginationUrlPage:
+        """
+        Retrieve a single page of OriginationUrlInstance records from the API.
+        Request is executed immediately
+
+        :param page_token: PageToken provided by the API
+        :param page_number: Page Number, this value is simply for client state
+        :param page_size: Number of records to return, defaults to 50
+
+        :returns: Page of OriginationUrlInstance
+        """
+        data = values.of(
+            {
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = self._version.page(method="GET", uri=self._uri, params=data)
+        return OriginationUrlPage(self._version, response, self._solution)
+
+    async def page_async(
+        self,
+        page_token: Union[str, object] = values.unset,
+        page_number: Union[int, object] = values.unset,
+        page_size: Union[int, object] = values.unset,
+    ) -> OriginationUrlPage:
+        """
+        Asynchronously retrieve a single page of OriginationUrlInstance records from the API.
+        Request is executed immediately
+
+        :param page_token: PageToken provided by the API
+        :param page_number: Page Number, this value is simply for client state
+        :param page_size: Number of records to return, defaults to 50
+
+        :returns: Page of OriginationUrlInstance
+        """
+        data = values.of(
+            {
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = await self._version.page_async(
+            method="GET", uri=self._uri, params=data
+        )
+        return OriginationUrlPage(self._version, response, self._solution)
+
+    def get_page(self, target_url: str) -> OriginationUrlPage:
+        """
+        Retrieve a specific page of OriginationUrlInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of OriginationUrlInstance
+        """
+        response = self._version.domain.twilio.request("GET", target_url)
+        return OriginationUrlPage(self._version, response, self._solution)
+
+    async def get_page_async(self, target_url: str) -> OriginationUrlPage:
+        """
+        Asynchronously retrieve a specific page of OriginationUrlInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of OriginationUrlInstance
+        """
+        response = await self._version.domain.twilio.request_async("GET", target_url)
+        return OriginationUrlPage(self._version, response, self._solution)
+
+    def get(self, sid: str) -> OriginationUrlContext:
+        """
+        Constructs a OriginationUrlContext
+
+        :param sid: The unique string that we created to identify the OriginationUrl resource to update.
+        """
+        return OriginationUrlContext(
+            self._version, trunk_sid=self._solution["trunk_sid"], sid=sid
+        )
+
+    def __call__(self, sid: str) -> OriginationUrlContext:
+        """
+        Constructs a OriginationUrlContext
+
+        :param sid: The unique string that we created to identify the OriginationUrl resource to update.
+        """
+        return OriginationUrlContext(
+            self._version, trunk_sid=self._solution["trunk_sid"], sid=sid
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Trunking.V1.OriginationUrlList>"

venv/lib/python3.11/site-packages/twilio/rest/trunking/v1/trunk/phone_number.py

@@ -0,0 +1,562 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Trunking
+    This is the public Twilio REST API.
+
+    NOTE: This class is auto generated by OpenAPI Generator.
+    https://openapi-generator.tech
+    Do not edit the class manually.
+"""
+
+
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Union, Iterator, AsyncIterator
+from twilio.base import deserialize, values
+from twilio.base.instance_context import InstanceContext
+from twilio.base.instance_resource import InstanceResource
+from twilio.base.list_resource import ListResource
+from twilio.base.version import Version
+from twilio.base.page import Page
+
+
+class PhoneNumberInstance(InstanceResource):
+    class AddressRequirement(object):
+        NONE = "none"
+        ANY = "any"
+        LOCAL = "local"
+        FOREIGN = "foreign"
+
+    """
+    :ivar account_sid: The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the PhoneNumber resource.
+    :ivar address_requirements: 
+    :ivar api_version: The API version used to start a new TwiML session.
+    :ivar beta: Whether the phone number is new to the Twilio platform. Can be: `true` or `false`.
+    :ivar capabilities: The set of Boolean properties that indicate whether a phone number can receive calls or messages.  Capabilities are  `Voice`, `SMS`, and `MMS` and each capability can be: `true` or `false`.
+    :ivar date_created: The date and time in GMT when the resource was created specified in [RFC 2822](https://www.ietf.org/rfc/rfc2822.txt) format.
+    :ivar date_updated: The date and time in GMT when the resource was last updated specified in [RFC 2822](https://www.ietf.org/rfc/rfc2822.txt) format.
+    :ivar friendly_name: The string that you assigned to describe the resource.
+    :ivar links: The URLs of related resources.
+    :ivar phone_number: The phone number in [E.164](https://www.twilio.com/docs/glossary/what-e164) format, which consists of a + followed by the country code and subscriber number.
+    :ivar sid: The unique string that we created to identify the PhoneNumber resource.
+    :ivar sms_application_sid: The SID of the application that handles SMS messages sent to the phone number. If an `sms_application_sid` is present, we ignore all `sms_*_url` values and use those of the application.
+    :ivar sms_fallback_method: The HTTP method we use to call `sms_fallback_url`. Can be: `GET` or `POST`.
+    :ivar sms_fallback_url: The URL that we call using the `sms_fallback_method` when an error occurs while retrieving or executing the TwiML from `sms_url`.
+    :ivar sms_method: The HTTP method we use to call `sms_url`. Can be: `GET` or `POST`.
+    :ivar sms_url: The URL we call using the `sms_method` when the phone number receives an incoming SMS message.
+    :ivar status_callback: The URL we call using the `status_callback_method` to send status information to your application.
+    :ivar status_callback_method: The HTTP method we use to call `status_callback`. Can be: `GET` or `POST`.
+    :ivar trunk_sid: The SID of the Trunk that handles calls to the phone number. If a `trunk_sid` is present, we ignore all of the voice URLs and voice applications and use those set on the Trunk. Setting a `trunk_sid` will automatically delete your `voice_application_sid` and vice versa.
+    :ivar url: The absolute URL of the resource.
+    :ivar voice_application_sid: The SID of the application that handles calls to the phone number. If a `voice_application_sid` is present, we ignore all of the voice URLs and use those set on the application. Setting a `voice_application_sid` will automatically delete your `trunk_sid` and vice versa.
+    :ivar voice_caller_id_lookup: Whether we look up the caller's caller-ID name from the CNAM database ($0.01 per look up). Can be: `true` or `false`.
+    :ivar voice_fallback_method: The HTTP method that we use to call `voice_fallback_url`. Can be: `GET` or `POST`.
+    :ivar voice_fallback_url: The URL that we call using the `voice_fallback_method` when an error occurs retrieving or executing the TwiML requested by `url`.
+    :ivar voice_method: The HTTP method we use to call `voice_url`. Can be: `GET` or `POST`.
+    :ivar voice_url: The URL we call using the `voice_method` when the phone number receives a call. The `voice_url` is not be used if a `voice_application_sid` or a `trunk_sid` is set.
+    """
+
+    def __init__(
+        self,
+        version: Version,
+        payload: Dict[str, Any],
+        trunk_sid: str,
+        sid: Optional[str] = None,
+    ):
+        super().__init__(version)
+
+        self.account_sid: Optional[str] = payload.get("account_sid")
+        self.address_requirements: Optional[
+            "PhoneNumberInstance.AddressRequirement"
+        ] = payload.get("address_requirements")
+        self.api_version: Optional[str] = payload.get("api_version")
+        self.beta: Optional[bool] = payload.get("beta")
+        self.capabilities: Optional[Dict[str, object]] = payload.get("capabilities")
+        self.date_created: Optional[datetime] = deserialize.iso8601_datetime(
+            payload.get("date_created")
+        )
+        self.date_updated: Optional[datetime] = deserialize.iso8601_datetime(
+            payload.get("date_updated")
+        )
+        self.friendly_name: Optional[str] = payload.get("friendly_name")
+        self.links: Optional[Dict[str, object]] = payload.get("links")
+        self.phone_number: Optional[str] = payload.get("phone_number")
+        self.sid: Optional[str] = payload.get("sid")
+        self.sms_application_sid: Optional[str] = payload.get("sms_application_sid")
+        self.sms_fallback_method: Optional[str] = payload.get("sms_fallback_method")
+        self.sms_fallback_url: Optional[str] = payload.get("sms_fallback_url")
+        self.sms_method: Optional[str] = payload.get("sms_method")
+        self.sms_url: Optional[str] = payload.get("sms_url")
+        self.status_callback: Optional[str] = payload.get("status_callback")
+        self.status_callback_method: Optional[str] = payload.get(
+            "status_callback_method"
+        )
+        self.trunk_sid: Optional[str] = payload.get("trunk_sid")
+        self.url: Optional[str] = payload.get("url")
+        self.voice_application_sid: Optional[str] = payload.get("voice_application_sid")
+        self.voice_caller_id_lookup: Optional[bool] = payload.get(
+            "voice_caller_id_lookup"
+        )
+        self.voice_fallback_method: Optional[str] = payload.get("voice_fallback_method")
+        self.voice_fallback_url: Optional[str] = payload.get("voice_fallback_url")
+        self.voice_method: Optional[str] = payload.get("voice_method")
+        self.voice_url: Optional[str] = payload.get("voice_url")
+
+        self._solution = {
+            "trunk_sid": trunk_sid,
+            "sid": sid or self.sid,
+        }
+        self._context: Optional[PhoneNumberContext] = None
+
+    @property
+    def _proxy(self) -> "PhoneNumberContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: PhoneNumberContext for this PhoneNumberInstance
+        """
+        if self._context is None:
+            self._context = PhoneNumberContext(
+                self._version,
+                trunk_sid=self._solution["trunk_sid"],
+                sid=self._solution["sid"],
+            )
+        return self._context
+
+    def delete(self) -> bool:
+        """
+        Deletes the PhoneNumberInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return self._proxy.delete()
+
+    async def delete_async(self) -> bool:
+        """
+        Asynchronous coroutine that deletes the PhoneNumberInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return await self._proxy.delete_async()
+
+    def fetch(self) -> "PhoneNumberInstance":
+        """
+        Fetch the PhoneNumberInstance
+
+
+        :returns: The fetched PhoneNumberInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "PhoneNumberInstance":
+        """
+        Asynchronous coroutine to fetch the PhoneNumberInstance
+
+
+        :returns: The fetched PhoneNumberInstance
+        """
+        return await self._proxy.fetch_async()
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        context = " ".join("{}={}".format(k, v) for k, v in self._solution.items())
+        return "<Twilio.Trunking.V1.PhoneNumberInstance {}>".format(context)
+
+
+class PhoneNumberContext(InstanceContext):
+    def __init__(self, version: Version, trunk_sid: str, sid: str):
+        """
+        Initialize the PhoneNumberContext
+
+        :param version: Version that contains the resource
+        :param trunk_sid: The SID of the Trunk from which to fetch the PhoneNumber resource.
+        :param sid: The unique string that we created to identify the PhoneNumber resource to fetch.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "trunk_sid": trunk_sid,
+            "sid": sid,
+        }
+        self._uri = "/Trunks/{trunk_sid}/PhoneNumbers/{sid}".format(**self._solution)
+
+    def delete(self) -> bool:
+        """
+        Deletes the PhoneNumberInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return self._version.delete(
+            method="DELETE",
+            uri=self._uri,
+        )
+
+    async def delete_async(self) -> bool:
+        """
+        Asynchronous coroutine that deletes the PhoneNumberInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return await self._version.delete_async(
+            method="DELETE",
+            uri=self._uri,
+        )
+
+    def fetch(self) -> PhoneNumberInstance:
+        """
+        Fetch the PhoneNumberInstance
+
+
+        :returns: The fetched PhoneNumberInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return PhoneNumberInstance(
+            self._version,
+            payload,
+            trunk_sid=self._solution["trunk_sid"],
+            sid=self._solution["sid"],
+        )
+
+    async def fetch_async(self) -> PhoneNumberInstance:
+        """
+        Asynchronous coroutine to fetch the PhoneNumberInstance
+
+
+        :returns: The fetched PhoneNumberInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return PhoneNumberInstance(
+            self._version,
+            payload,
+            trunk_sid=self._solution["trunk_sid"],
+            sid=self._solution["sid"],
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        context = " ".join("{}={}".format(k, v) for k, v in self._solution.items())
+        return "<Twilio.Trunking.V1.PhoneNumberContext {}>".format(context)
+
+
+class PhoneNumberPage(Page):
+    def get_instance(self, payload: Dict[str, Any]) -> PhoneNumberInstance:
+        """
+        Build an instance of PhoneNumberInstance
+
+        :param payload: Payload response from the API
+        """
+        return PhoneNumberInstance(
+            self._version, payload, trunk_sid=self._solution["trunk_sid"]
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Trunking.V1.PhoneNumberPage>"
+
+
+class PhoneNumberList(ListResource):
+    def __init__(self, version: Version, trunk_sid: str):
+        """
+        Initialize the PhoneNumberList
+
+        :param version: Version that contains the resource
+        :param trunk_sid: The SID of the Trunk from which to read the PhoneNumber resources.
+
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "trunk_sid": trunk_sid,
+        }
+        self._uri = "/Trunks/{trunk_sid}/PhoneNumbers".format(**self._solution)
+
+    def create(self, phone_number_sid: str) -> PhoneNumberInstance:
+        """
+        Create the PhoneNumberInstance
+
+        :param phone_number_sid: The SID of the [Incoming Phone Number](https://www.twilio.com/docs/phone-numbers/api/incomingphonenumber-resource) that you want to associate with the trunk.
+
+        :returns: The created PhoneNumberInstance
+        """
+        data = values.of(
+            {
+                "PhoneNumberSid": phone_number_sid,
+            }
+        )
+
+        payload = self._version.create(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return PhoneNumberInstance(
+            self._version, payload, trunk_sid=self._solution["trunk_sid"]
+        )
+
+    async def create_async(self, phone_number_sid: str) -> PhoneNumberInstance:
+        """
+        Asynchronously create the PhoneNumberInstance
+
+        :param phone_number_sid: The SID of the [Incoming Phone Number](https://www.twilio.com/docs/phone-numbers/api/incomingphonenumber-resource) that you want to associate with the trunk.
+
+        :returns: The created PhoneNumberInstance
+        """
+        data = values.of(
+            {
+                "PhoneNumberSid": phone_number_sid,
+            }
+        )
+
+        payload = await self._version.create_async(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return PhoneNumberInstance(
+            self._version, payload, trunk_sid=self._solution["trunk_sid"]
+        )
+
+    def stream(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> Iterator[PhoneNumberInstance]:
+        """
+        Streams PhoneNumberInstance records from the API as a generator stream.
+        This operation lazily loads records as efficiently as possible until the limit
+        is reached.
+        The results are returned as a generator, so this operation is memory efficient.
+
+        :param limit: Upper limit for the number of records to return. stream()
+                      guarantees to never return more than limit.  Default is no limit
+        :param page_size: Number of records to fetch per request, when not set will use
+                          the default value of 50 records.  If no page_size is defined
+                          but a limit is defined, stream() will attempt to read the
+                          limit with the most efficient page size, i.e. min(limit, 1000)
+
+        :returns: Generator that will yield up to limit results
+        """
+        limits = self._version.read_limits(limit, page_size)
+        page = self.page(page_size=limits["page_size"])
+
+        return self._version.stream(page, limits["limit"])
+
+    async def stream_async(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> AsyncIterator[PhoneNumberInstance]:
+        """
+        Asynchronously streams PhoneNumberInstance records from the API as a generator stream.
+        This operation lazily loads records as efficiently as possible until the limit
+        is reached.
+        The results are returned as a generator, so this operation is memory efficient.
+
+        :param limit: Upper limit for the number of records to return. stream()
+                      guarantees to never return more than limit.  Default is no limit
+        :param page_size: Number of records to fetch per request, when not set will use
+                          the default value of 50 records.  If no page_size is defined
+                          but a limit is defined, stream() will attempt to read the
+                          limit with the most efficient page size, i.e. min(limit, 1000)
+
+        :returns: Generator that will yield up to limit results
+        """
+        limits = self._version.read_limits(limit, page_size)
+        page = await self.page_async(page_size=limits["page_size"])
+
+        return self._version.stream_async(page, limits["limit"])
+
+    def list(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> List[PhoneNumberInstance]:
+        """
+        Lists PhoneNumberInstance records from the API as a list.
+        Unlike stream(), this operation is eager and will load `limit` records into
+        memory before returning.
+
+        :param limit: Upper limit for the number of records to return. list() guarantees
+                      never to return more than limit.  Default is no limit
+        :param page_size: Number of records to fetch per request, when not set will use
+                          the default value of 50 records.  If no page_size is defined
+                          but a limit is defined, list() will attempt to read the limit
+                          with the most efficient page size, i.e. min(limit, 1000)
+
+        :returns: list that will contain up to limit results
+        """
+        return list(
+            self.stream(
+                limit=limit,
+                page_size=page_size,
+            )
+        )
+
+    async def list_async(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> List[PhoneNumberInstance]:
+        """
+        Asynchronously lists PhoneNumberInstance records from the API as a list.
+        Unlike stream(), this operation is eager and will load `limit` records into
+        memory before returning.
+
+        :param limit: Upper limit for the number of records to return. list() guarantees
+                      never to return more than limit.  Default is no limit
+        :param page_size: Number of records to fetch per request, when not set will use
+                          the default value of 50 records.  If no page_size is defined
+                          but a limit is defined, list() will attempt to read the limit
+                          with the most efficient page size, i.e. min(limit, 1000)
+
+        :returns: list that will contain up to limit results
+        """
+        return [
+            record
+            async for record in await self.stream_async(
+                limit=limit,
+                page_size=page_size,
+            )
+        ]
+
+    def page(
+        self,
+        page_token: Union[str, object] = values.unset,
+        page_number: Union[int, object] = values.unset,
+        page_size: Union[int, object] = values.unset,
+    ) -> PhoneNumberPage:
+        """
+        Retrieve a single page of PhoneNumberInstance records from the API.
+        Request is executed immediately
+
+        :param page_token: PageToken provided by the API
+        :param page_number: Page Number, this value is simply for client state
+        :param page_size: Number of records to return, defaults to 50
+
+        :returns: Page of PhoneNumberInstance
+        """
+        data = values.of(
+            {
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = self._version.page(method="GET", uri=self._uri, params=data)
+        return PhoneNumberPage(self._version, response, self._solution)
+
+    async def page_async(
+        self,
+        page_token: Union[str, object] = values.unset,
+        page_number: Union[int, object] = values.unset,
+        page_size: Union[int, object] = values.unset,
+    ) -> PhoneNumberPage:
+        """
+        Asynchronously retrieve a single page of PhoneNumberInstance records from the API.
+        Request is executed immediately
+
+        :param page_token: PageToken provided by the API
+        :param page_number: Page Number, this value is simply for client state
+        :param page_size: Number of records to return, defaults to 50
+
+        :returns: Page of PhoneNumberInstance
+        """
+        data = values.of(
+            {
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = await self._version.page_async(
+            method="GET", uri=self._uri, params=data
+        )
+        return PhoneNumberPage(self._version, response, self._solution)
+
+    def get_page(self, target_url: str) -> PhoneNumberPage:
+        """
+        Retrieve a specific page of PhoneNumberInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of PhoneNumberInstance
+        """
+        response = self._version.domain.twilio.request("GET", target_url)
+        return PhoneNumberPage(self._version, response, self._solution)
+
+    async def get_page_async(self, target_url: str) -> PhoneNumberPage:
+        """
+        Asynchronously retrieve a specific page of PhoneNumberInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of PhoneNumberInstance
+        """
+        response = await self._version.domain.twilio.request_async("GET", target_url)
+        return PhoneNumberPage(self._version, response, self._solution)
+
+    def get(self, sid: str) -> PhoneNumberContext:
+        """
+        Constructs a PhoneNumberContext
+
+        :param sid: The unique string that we created to identify the PhoneNumber resource to fetch.
+        """
+        return PhoneNumberContext(
+            self._version, trunk_sid=self._solution["trunk_sid"], sid=sid
+        )
+
+    def __call__(self, sid: str) -> PhoneNumberContext:
+        """
+        Constructs a PhoneNumberContext
+
+        :param sid: The unique string that we created to identify the PhoneNumber resource to fetch.
+        """
+        return PhoneNumberContext(
+            self._version, trunk_sid=self._solution["trunk_sid"], sid=sid
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Trunking.V1.PhoneNumberList>"

venv/lib/python3.11/site-packages/twilio/rest/trunking/v1/trunk/recording.py

@@ -0,0 +1,291 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Trunking
+    This is the public Twilio REST API.
+
+    NOTE: This class is auto generated by OpenAPI Generator.
+    https://openapi-generator.tech
+    Do not edit the class manually.
+"""
+
+
+from typing import Any, Dict, Optional, Union
+from twilio.base import values
+from twilio.base.instance_context import InstanceContext
+from twilio.base.instance_resource import InstanceResource
+from twilio.base.list_resource import ListResource
+from twilio.base.version import Version
+
+
+class RecordingInstance(InstanceResource):
+    class RecordingMode(object):
+        DO_NOT_RECORD = "do-not-record"
+        RECORD_FROM_RINGING = "record-from-ringing"
+        RECORD_FROM_ANSWER = "record-from-answer"
+        RECORD_FROM_RINGING_DUAL = "record-from-ringing-dual"
+        RECORD_FROM_ANSWER_DUAL = "record-from-answer-dual"
+
+    class RecordingTrim(object):
+        TRIM_SILENCE = "trim-silence"
+        DO_NOT_TRIM = "do-not-trim"
+
+    """
+    :ivar mode: 
+    :ivar trim: 
+    """
+
+    def __init__(self, version: Version, payload: Dict[str, Any], trunk_sid: str):
+        super().__init__(version)
+
+        self.mode: Optional["RecordingInstance.RecordingMode"] = payload.get("mode")
+        self.trim: Optional["RecordingInstance.RecordingTrim"] = payload.get("trim")
+
+        self._solution = {
+            "trunk_sid": trunk_sid,
+        }
+        self._context: Optional[RecordingContext] = None
+
+    @property
+    def _proxy(self) -> "RecordingContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: RecordingContext for this RecordingInstance
+        """
+        if self._context is None:
+            self._context = RecordingContext(
+                self._version,
+                trunk_sid=self._solution["trunk_sid"],
+            )
+        return self._context
+
+    def fetch(self) -> "RecordingInstance":
+        """
+        Fetch the RecordingInstance
+
+
+        :returns: The fetched RecordingInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "RecordingInstance":
+        """
+        Asynchronous coroutine to fetch the RecordingInstance
+
+
+        :returns: The fetched RecordingInstance
+        """
+        return await self._proxy.fetch_async()
+
+    def update(
+        self,
+        mode: Union["RecordingInstance.RecordingMode", object] = values.unset,
+        trim: Union["RecordingInstance.RecordingTrim", object] = values.unset,
+    ) -> "RecordingInstance":
+        """
+        Update the RecordingInstance
+
+        :param mode:
+        :param trim:
+
+        :returns: The updated RecordingInstance
+        """
+        return self._proxy.update(
+            mode=mode,
+            trim=trim,
+        )
+
+    async def update_async(
+        self,
+        mode: Union["RecordingInstance.RecordingMode", object] = values.unset,
+        trim: Union["RecordingInstance.RecordingTrim", object] = values.unset,
+    ) -> "RecordingInstance":
+        """
+        Asynchronous coroutine to update the RecordingInstance
+
+        :param mode:
+        :param trim:
+
+        :returns: The updated RecordingInstance
+        """
+        return await self._proxy.update_async(
+            mode=mode,
+            trim=trim,
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        context = " ".join("{}={}".format(k, v) for k, v in self._solution.items())
+        return "<Twilio.Trunking.V1.RecordingInstance {}>".format(context)
+
+
+class RecordingContext(InstanceContext):
+    def __init__(self, version: Version, trunk_sid: str):
+        """
+        Initialize the RecordingContext
+
+        :param version: Version that contains the resource
+        :param trunk_sid: The SID of the Trunk that will have its recording settings updated.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "trunk_sid": trunk_sid,
+        }
+        self._uri = "/Trunks/{trunk_sid}/Recording".format(**self._solution)
+
+    def fetch(self) -> RecordingInstance:
+        """
+        Fetch the RecordingInstance
+
+
+        :returns: The fetched RecordingInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return RecordingInstance(
+            self._version,
+            payload,
+            trunk_sid=self._solution["trunk_sid"],
+        )
+
+    async def fetch_async(self) -> RecordingInstance:
+        """
+        Asynchronous coroutine to fetch the RecordingInstance
+
+
+        :returns: The fetched RecordingInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return RecordingInstance(
+            self._version,
+            payload,
+            trunk_sid=self._solution["trunk_sid"],
+        )
+
+    def update(
+        self,
+        mode: Union["RecordingInstance.RecordingMode", object] = values.unset,
+        trim: Union["RecordingInstance.RecordingTrim", object] = values.unset,
+    ) -> RecordingInstance:
+        """
+        Update the RecordingInstance
+
+        :param mode:
+        :param trim:
+
+        :returns: The updated RecordingInstance
+        """
+        data = values.of(
+            {
+                "Mode": mode,
+                "Trim": trim,
+            }
+        )
+
+        payload = self._version.update(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return RecordingInstance(
+            self._version, payload, trunk_sid=self._solution["trunk_sid"]
+        )
+
+    async def update_async(
+        self,
+        mode: Union["RecordingInstance.RecordingMode", object] = values.unset,
+        trim: Union["RecordingInstance.RecordingTrim", object] = values.unset,
+    ) -> RecordingInstance:
+        """
+        Asynchronous coroutine to update the RecordingInstance
+
+        :param mode:
+        :param trim:
+
+        :returns: The updated RecordingInstance
+        """
+        data = values.of(
+            {
+                "Mode": mode,
+                "Trim": trim,
+            }
+        )
+
+        payload = await self._version.update_async(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return RecordingInstance(
+            self._version, payload, trunk_sid=self._solution["trunk_sid"]
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        context = " ".join("{}={}".format(k, v) for k, v in self._solution.items())
+        return "<Twilio.Trunking.V1.RecordingContext {}>".format(context)
+
+
+class RecordingList(ListResource):
+    def __init__(self, version: Version, trunk_sid: str):
+        """
+        Initialize the RecordingList
+
+        :param version: Version that contains the resource
+        :param trunk_sid: The SID of the Trunk from which to fetch the recording settings.
+
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "trunk_sid": trunk_sid,
+        }
+
+    def get(self) -> RecordingContext:
+        """
+        Constructs a RecordingContext
+
+        """
+        return RecordingContext(self._version, trunk_sid=self._solution["trunk_sid"])
+
+    def __call__(self) -> RecordingContext:
+        """
+        Constructs a RecordingContext
+
+        """
+        return RecordingContext(self._version, trunk_sid=self._solution["trunk_sid"])
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Trunking.V1.RecordingList>"