Initial commit: Email alerts application

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

@@ -0,0 +1,58 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Pricing
+    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.pricing.v1.messaging import MessagingList
+from twilio.rest.pricing.v1.phone_number import PhoneNumberList
+from twilio.rest.pricing.v1.voice import VoiceList
+
+
+class V1(Version):
+    def __init__(self, domain: Domain):
+        """
+        Initialize the V1 version of Pricing
+
+        :param domain: The Twilio.pricing domain
+        """
+        super().__init__(domain, "v1")
+        self._messaging: Optional[MessagingList] = None
+        self._phone_numbers: Optional[PhoneNumberList] = None
+        self._voice: Optional[VoiceList] = None
+
+    @property
+    def messaging(self) -> MessagingList:
+        if self._messaging is None:
+            self._messaging = MessagingList(self)
+        return self._messaging
+
+    @property
+    def phone_numbers(self) -> PhoneNumberList:
+        if self._phone_numbers is None:
+            self._phone_numbers = PhoneNumberList(self)
+        return self._phone_numbers
+
+    @property
+    def voice(self) -> VoiceList:
+        if self._voice is None:
+            self._voice = VoiceList(self)
+        return self._voice
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Pricing.V1>"

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

@@ -0,0 +1,54 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Pricing
+    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.list_resource import ListResource
+from twilio.base.version import Version
+
+from twilio.rest.pricing.v1.messaging.country import CountryList
+
+
+class MessagingList(ListResource):
+    def __init__(self, version: Version):
+        """
+        Initialize the MessagingList
+
+        :param version: Version that contains the resource
+
+        """
+        super().__init__(version)
+
+        self._uri = "/Messaging"
+
+        self._countries: Optional[CountryList] = None
+
+    @property
+    def countries(self) -> CountryList:
+        """
+        Access the countries
+        """
+        if self._countries is None:
+            self._countries = CountryList(self._version)
+        return self._countries
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Pricing.V1.MessagingList>"

venv/lib/python3.11/site-packages/twilio/rest/pricing/v1/messaging/country.py

@@ -0,0 +1,400 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Pricing
+    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, List, Optional, Union, Iterator, AsyncIterator
+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
+from twilio.base.page import Page
+
+
+class CountryInstance(InstanceResource):
+
+    """
+    :ivar country: The name of the country.
+    :ivar iso_country: The [ISO country code](http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2).
+    :ivar outbound_sms_prices: The list of [OutboundSMSPrice](https://www.twilio.com/docs/sms/api/pricing#outbound-sms-price) records that represent the price to send a message for each MCC/MNC applicable in this country.
+    :ivar inbound_sms_prices: The list of [InboundPrice](https://www.twilio.com/docs/sms/api/pricing#inbound-price) records that describe the price to receive an inbound SMS to the different Twilio phone number types supported in this country
+    :ivar price_unit: The currency in which prices are measured, specified in [ISO 4127](http://www.iso.org/iso/home/standards/currency_codes.htm) format (e.g. `usd`, `eur`, `jpy`).
+    :ivar url: The absolute URL of the resource.
+    """
+
+    def __init__(
+        self,
+        version: Version,
+        payload: Dict[str, Any],
+        iso_country: Optional[str] = None,
+    ):
+        super().__init__(version)
+
+        self.country: Optional[str] = payload.get("country")
+        self.iso_country: Optional[str] = payload.get("iso_country")
+        self.outbound_sms_prices: Optional[List[str]] = payload.get(
+            "outbound_sms_prices"
+        )
+        self.inbound_sms_prices: Optional[List[str]] = payload.get("inbound_sms_prices")
+        self.price_unit: Optional[str] = payload.get("price_unit")
+        self.url: Optional[str] = payload.get("url")
+
+        self._solution = {
+            "iso_country": iso_country or self.iso_country,
+        }
+        self._context: Optional[CountryContext] = None
+
+    @property
+    def _proxy(self) -> "CountryContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: CountryContext for this CountryInstance
+        """
+        if self._context is None:
+            self._context = CountryContext(
+                self._version,
+                iso_country=self._solution["iso_country"],
+            )
+        return self._context
+
+    def fetch(self) -> "CountryInstance":
+        """
+        Fetch the CountryInstance
+
+
+        :returns: The fetched CountryInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "CountryInstance":
+        """
+        Asynchronous coroutine to fetch the CountryInstance
+
+
+        :returns: The fetched CountryInstance
+        """
+        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.Pricing.V1.CountryInstance {}>".format(context)
+
+
+class CountryContext(InstanceContext):
+    def __init__(self, version: Version, iso_country: str):
+        """
+        Initialize the CountryContext
+
+        :param version: Version that contains the resource
+        :param iso_country: The [ISO country code](http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) of the pricing information to fetch.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "iso_country": iso_country,
+        }
+        self._uri = "/Messaging/Countries/{iso_country}".format(**self._solution)
+
+    def fetch(self) -> CountryInstance:
+        """
+        Fetch the CountryInstance
+
+
+        :returns: The fetched CountryInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return CountryInstance(
+            self._version,
+            payload,
+            iso_country=self._solution["iso_country"],
+        )
+
+    async def fetch_async(self) -> CountryInstance:
+        """
+        Asynchronous coroutine to fetch the CountryInstance
+
+
+        :returns: The fetched CountryInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return CountryInstance(
+            self._version,
+            payload,
+            iso_country=self._solution["iso_country"],
+        )
+
+    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.Pricing.V1.CountryContext {}>".format(context)
+
+
+class CountryPage(Page):
+    def get_instance(self, payload: Dict[str, Any]) -> CountryInstance:
+        """
+        Build an instance of CountryInstance
+
+        :param payload: Payload response from the API
+        """
+        return CountryInstance(self._version, payload)
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Pricing.V1.CountryPage>"
+
+
+class CountryList(ListResource):
+    def __init__(self, version: Version):
+        """
+        Initialize the CountryList
+
+        :param version: Version that contains the resource
+
+        """
+        super().__init__(version)
+
+        self._uri = "/Messaging/Countries"
+
+    def stream(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> Iterator[CountryInstance]:
+        """
+        Streams CountryInstance 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[CountryInstance]:
+        """
+        Asynchronously streams CountryInstance 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[CountryInstance]:
+        """
+        Lists CountryInstance 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[CountryInstance]:
+        """
+        Asynchronously lists CountryInstance 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,
+    ) -> CountryPage:
+        """
+        Retrieve a single page of CountryInstance 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 CountryInstance
+        """
+        data = values.of(
+            {
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = self._version.page(method="GET", uri=self._uri, params=data)
+        return CountryPage(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,
+    ) -> CountryPage:
+        """
+        Asynchronously retrieve a single page of CountryInstance 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 CountryInstance
+        """
+        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 CountryPage(self._version, response)
+
+    def get_page(self, target_url: str) -> CountryPage:
+        """
+        Retrieve a specific page of CountryInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of CountryInstance
+        """
+        response = self._version.domain.twilio.request("GET", target_url)
+        return CountryPage(self._version, response)
+
+    async def get_page_async(self, target_url: str) -> CountryPage:
+        """
+        Asynchronously retrieve a specific page of CountryInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of CountryInstance
+        """
+        response = await self._version.domain.twilio.request_async("GET", target_url)
+        return CountryPage(self._version, response)
+
+    def get(self, iso_country: str) -> CountryContext:
+        """
+        Constructs a CountryContext
+
+        :param iso_country: The [ISO country code](http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) of the pricing information to fetch.
+        """
+        return CountryContext(self._version, iso_country=iso_country)
+
+    def __call__(self, iso_country: str) -> CountryContext:
+        """
+        Constructs a CountryContext
+
+        :param iso_country: The [ISO country code](http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) of the pricing information to fetch.
+        """
+        return CountryContext(self._version, iso_country=iso_country)
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Pricing.V1.CountryList>"

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

@@ -0,0 +1,54 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Pricing
+    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.list_resource import ListResource
+from twilio.base.version import Version
+
+from twilio.rest.pricing.v1.phone_number.country import CountryList
+
+
+class PhoneNumberList(ListResource):
+    def __init__(self, version: Version):
+        """
+        Initialize the PhoneNumberList
+
+        :param version: Version that contains the resource
+
+        """
+        super().__init__(version)
+
+        self._uri = "/PhoneNumbers"
+
+        self._countries: Optional[CountryList] = None
+
+    @property
+    def countries(self) -> CountryList:
+        """
+        Access the countries
+        """
+        if self._countries is None:
+            self._countries = CountryList(self._version)
+        return self._countries
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Pricing.V1.PhoneNumberList>"

venv/lib/python3.11/site-packages/twilio/rest/pricing/v1/phone_number/country.py

@@ -0,0 +1,398 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Pricing
+    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, List, Optional, Union, Iterator, AsyncIterator
+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
+from twilio.base.page import Page
+
+
+class CountryInstance(InstanceResource):
+
+    """
+    :ivar country: The name of the country.
+    :ivar iso_country: The [ISO country code](http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2).
+    :ivar phone_number_prices: The list of [PhoneNumberPrice](https://www.twilio.com/docs/phone-numbers/pricing#phone-number-price) records.
+    :ivar price_unit: The currency in which prices are measured, specified in [ISO 4127](http://www.iso.org/iso/home/standards/currency_codes.htm) format (e.g. `usd`, `eur`, `jpy`).
+    :ivar url: The absolute URL of the resource.
+    """
+
+    def __init__(
+        self,
+        version: Version,
+        payload: Dict[str, Any],
+        iso_country: Optional[str] = None,
+    ):
+        super().__init__(version)
+
+        self.country: Optional[str] = payload.get("country")
+        self.iso_country: Optional[str] = payload.get("iso_country")
+        self.phone_number_prices: Optional[List[str]] = payload.get(
+            "phone_number_prices"
+        )
+        self.price_unit: Optional[str] = payload.get("price_unit")
+        self.url: Optional[str] = payload.get("url")
+
+        self._solution = {
+            "iso_country": iso_country or self.iso_country,
+        }
+        self._context: Optional[CountryContext] = None
+
+    @property
+    def _proxy(self) -> "CountryContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: CountryContext for this CountryInstance
+        """
+        if self._context is None:
+            self._context = CountryContext(
+                self._version,
+                iso_country=self._solution["iso_country"],
+            )
+        return self._context
+
+    def fetch(self) -> "CountryInstance":
+        """
+        Fetch the CountryInstance
+
+
+        :returns: The fetched CountryInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "CountryInstance":
+        """
+        Asynchronous coroutine to fetch the CountryInstance
+
+
+        :returns: The fetched CountryInstance
+        """
+        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.Pricing.V1.CountryInstance {}>".format(context)
+
+
+class CountryContext(InstanceContext):
+    def __init__(self, version: Version, iso_country: str):
+        """
+        Initialize the CountryContext
+
+        :param version: Version that contains the resource
+        :param iso_country: The [ISO country code](http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) of the pricing information to fetch.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "iso_country": iso_country,
+        }
+        self._uri = "/PhoneNumbers/Countries/{iso_country}".format(**self._solution)
+
+    def fetch(self) -> CountryInstance:
+        """
+        Fetch the CountryInstance
+
+
+        :returns: The fetched CountryInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return CountryInstance(
+            self._version,
+            payload,
+            iso_country=self._solution["iso_country"],
+        )
+
+    async def fetch_async(self) -> CountryInstance:
+        """
+        Asynchronous coroutine to fetch the CountryInstance
+
+
+        :returns: The fetched CountryInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return CountryInstance(
+            self._version,
+            payload,
+            iso_country=self._solution["iso_country"],
+        )
+
+    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.Pricing.V1.CountryContext {}>".format(context)
+
+
+class CountryPage(Page):
+    def get_instance(self, payload: Dict[str, Any]) -> CountryInstance:
+        """
+        Build an instance of CountryInstance
+
+        :param payload: Payload response from the API
+        """
+        return CountryInstance(self._version, payload)
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Pricing.V1.CountryPage>"
+
+
+class CountryList(ListResource):
+    def __init__(self, version: Version):
+        """
+        Initialize the CountryList
+
+        :param version: Version that contains the resource
+
+        """
+        super().__init__(version)
+
+        self._uri = "/PhoneNumbers/Countries"
+
+    def stream(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> Iterator[CountryInstance]:
+        """
+        Streams CountryInstance 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[CountryInstance]:
+        """
+        Asynchronously streams CountryInstance 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[CountryInstance]:
+        """
+        Lists CountryInstance 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[CountryInstance]:
+        """
+        Asynchronously lists CountryInstance 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,
+    ) -> CountryPage:
+        """
+        Retrieve a single page of CountryInstance 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 CountryInstance
+        """
+        data = values.of(
+            {
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = self._version.page(method="GET", uri=self._uri, params=data)
+        return CountryPage(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,
+    ) -> CountryPage:
+        """
+        Asynchronously retrieve a single page of CountryInstance 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 CountryInstance
+        """
+        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 CountryPage(self._version, response)
+
+    def get_page(self, target_url: str) -> CountryPage:
+        """
+        Retrieve a specific page of CountryInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of CountryInstance
+        """
+        response = self._version.domain.twilio.request("GET", target_url)
+        return CountryPage(self._version, response)
+
+    async def get_page_async(self, target_url: str) -> CountryPage:
+        """
+        Asynchronously retrieve a specific page of CountryInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of CountryInstance
+        """
+        response = await self._version.domain.twilio.request_async("GET", target_url)
+        return CountryPage(self._version, response)
+
+    def get(self, iso_country: str) -> CountryContext:
+        """
+        Constructs a CountryContext
+
+        :param iso_country: The [ISO country code](http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) of the pricing information to fetch.
+        """
+        return CountryContext(self._version, iso_country=iso_country)
+
+    def __call__(self, iso_country: str) -> CountryContext:
+        """
+        Constructs a CountryContext
+
+        :param iso_country: The [ISO country code](http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) of the pricing information to fetch.
+        """
+        return CountryContext(self._version, iso_country=iso_country)
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Pricing.V1.CountryList>"

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

@@ -0,0 +1,65 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Pricing
+    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.list_resource import ListResource
+from twilio.base.version import Version
+
+from twilio.rest.pricing.v1.voice.country import CountryList
+from twilio.rest.pricing.v1.voice.number import NumberList
+
+
+class VoiceList(ListResource):
+    def __init__(self, version: Version):
+        """
+        Initialize the VoiceList
+
+        :param version: Version that contains the resource
+
+        """
+        super().__init__(version)
+
+        self._uri = "/Voice"
+
+        self._countries: Optional[CountryList] = None
+        self._numbers: Optional[NumberList] = None
+
+    @property
+    def countries(self) -> CountryList:
+        """
+        Access the countries
+        """
+        if self._countries is None:
+            self._countries = CountryList(self._version)
+        return self._countries
+
+    @property
+    def numbers(self) -> NumberList:
+        """
+        Access the numbers
+        """
+        if self._numbers is None:
+            self._numbers = NumberList(self._version)
+        return self._numbers
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Pricing.V1.VoiceList>"

venv/lib/python3.11/site-packages/twilio/rest/pricing/v1/voice/country.py

@@ -0,0 +1,402 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Pricing
+    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, List, Optional, Union, Iterator, AsyncIterator
+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
+from twilio.base.page import Page
+
+
+class CountryInstance(InstanceResource):
+
+    """
+    :ivar country: The name of the country.
+    :ivar iso_country: The [ISO country code](http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2).
+    :ivar outbound_prefix_prices: The list of OutboundPrefixPrice records, which include a list of the `prefixes`, the `friendly_name`, `base_price`, and the   `current_price` for those prefixes.
+    :ivar inbound_call_prices: The list of [InboundCallPrice](https://www.twilio.com/docs/voice/pricing#inbound-call-price) records.
+    :ivar price_unit: The currency in which prices are measured, specified in [ISO 4127](http://www.iso.org/iso/home/standards/currency_codes.htm) format (e.g. `usd`, `eur`, `jpy`).
+    :ivar url: The absolute URL of the resource.
+    """
+
+    def __init__(
+        self,
+        version: Version,
+        payload: Dict[str, Any],
+        iso_country: Optional[str] = None,
+    ):
+        super().__init__(version)
+
+        self.country: Optional[str] = payload.get("country")
+        self.iso_country: Optional[str] = payload.get("iso_country")
+        self.outbound_prefix_prices: Optional[List[str]] = payload.get(
+            "outbound_prefix_prices"
+        )
+        self.inbound_call_prices: Optional[List[str]] = payload.get(
+            "inbound_call_prices"
+        )
+        self.price_unit: Optional[str] = payload.get("price_unit")
+        self.url: Optional[str] = payload.get("url")
+
+        self._solution = {
+            "iso_country": iso_country or self.iso_country,
+        }
+        self._context: Optional[CountryContext] = None
+
+    @property
+    def _proxy(self) -> "CountryContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: CountryContext for this CountryInstance
+        """
+        if self._context is None:
+            self._context = CountryContext(
+                self._version,
+                iso_country=self._solution["iso_country"],
+            )
+        return self._context
+
+    def fetch(self) -> "CountryInstance":
+        """
+        Fetch the CountryInstance
+
+
+        :returns: The fetched CountryInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "CountryInstance":
+        """
+        Asynchronous coroutine to fetch the CountryInstance
+
+
+        :returns: The fetched CountryInstance
+        """
+        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.Pricing.V1.CountryInstance {}>".format(context)
+
+
+class CountryContext(InstanceContext):
+    def __init__(self, version: Version, iso_country: str):
+        """
+        Initialize the CountryContext
+
+        :param version: Version that contains the resource
+        :param iso_country: The [ISO country code](http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) of the pricing information to fetch.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "iso_country": iso_country,
+        }
+        self._uri = "/Voice/Countries/{iso_country}".format(**self._solution)
+
+    def fetch(self) -> CountryInstance:
+        """
+        Fetch the CountryInstance
+
+
+        :returns: The fetched CountryInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return CountryInstance(
+            self._version,
+            payload,
+            iso_country=self._solution["iso_country"],
+        )
+
+    async def fetch_async(self) -> CountryInstance:
+        """
+        Asynchronous coroutine to fetch the CountryInstance
+
+
+        :returns: The fetched CountryInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return CountryInstance(
+            self._version,
+            payload,
+            iso_country=self._solution["iso_country"],
+        )
+
+    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.Pricing.V1.CountryContext {}>".format(context)
+
+
+class CountryPage(Page):
+    def get_instance(self, payload: Dict[str, Any]) -> CountryInstance:
+        """
+        Build an instance of CountryInstance
+
+        :param payload: Payload response from the API
+        """
+        return CountryInstance(self._version, payload)
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Pricing.V1.CountryPage>"
+
+
+class CountryList(ListResource):
+    def __init__(self, version: Version):
+        """
+        Initialize the CountryList
+
+        :param version: Version that contains the resource
+
+        """
+        super().__init__(version)
+
+        self._uri = "/Voice/Countries"
+
+    def stream(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> Iterator[CountryInstance]:
+        """
+        Streams CountryInstance 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[CountryInstance]:
+        """
+        Asynchronously streams CountryInstance 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[CountryInstance]:
+        """
+        Lists CountryInstance 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[CountryInstance]:
+        """
+        Asynchronously lists CountryInstance 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,
+    ) -> CountryPage:
+        """
+        Retrieve a single page of CountryInstance 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 CountryInstance
+        """
+        data = values.of(
+            {
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = self._version.page(method="GET", uri=self._uri, params=data)
+        return CountryPage(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,
+    ) -> CountryPage:
+        """
+        Asynchronously retrieve a single page of CountryInstance 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 CountryInstance
+        """
+        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 CountryPage(self._version, response)
+
+    def get_page(self, target_url: str) -> CountryPage:
+        """
+        Retrieve a specific page of CountryInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of CountryInstance
+        """
+        response = self._version.domain.twilio.request("GET", target_url)
+        return CountryPage(self._version, response)
+
+    async def get_page_async(self, target_url: str) -> CountryPage:
+        """
+        Asynchronously retrieve a specific page of CountryInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of CountryInstance
+        """
+        response = await self._version.domain.twilio.request_async("GET", target_url)
+        return CountryPage(self._version, response)
+
+    def get(self, iso_country: str) -> CountryContext:
+        """
+        Constructs a CountryContext
+
+        :param iso_country: The [ISO country code](http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) of the pricing information to fetch.
+        """
+        return CountryContext(self._version, iso_country=iso_country)
+
+    def __call__(self, iso_country: str) -> CountryContext:
+        """
+        Constructs a CountryContext
+
+        :param iso_country: The [ISO country code](http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) of the pricing information to fetch.
+        """
+        return CountryContext(self._version, iso_country=iso_country)
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Pricing.V1.CountryList>"

venv/lib/python3.11/site-packages/twilio/rest/pricing/v1/voice/number.py

@@ -0,0 +1,192 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Pricing
+    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
+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 NumberInstance(InstanceResource):
+
+    """
+    :ivar number: The phone number.
+    :ivar country: The name of the country.
+    :ivar iso_country: The [ISO country code](http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2).
+    :ivar outbound_call_price:
+    :ivar inbound_call_price:
+    :ivar price_unit: The currency in which prices are measured, specified in [ISO 4127](http://www.iso.org/iso/home/standards/currency_codes.htm) format (e.g. `usd`, `eur`, `jpy`).
+    :ivar url: The absolute URL of the resource.
+    """
+
+    def __init__(
+        self, version: Version, payload: Dict[str, Any], number: Optional[str] = None
+    ):
+        super().__init__(version)
+
+        self.number: Optional[str] = payload.get("number")
+        self.country: Optional[str] = payload.get("country")
+        self.iso_country: Optional[str] = payload.get("iso_country")
+        self.outbound_call_price: Optional[str] = payload.get("outbound_call_price")
+        self.inbound_call_price: Optional[str] = payload.get("inbound_call_price")
+        self.price_unit: Optional[str] = payload.get("price_unit")
+        self.url: Optional[str] = payload.get("url")
+
+        self._solution = {
+            "number": number or self.number,
+        }
+        self._context: Optional[NumberContext] = None
+
+    @property
+    def _proxy(self) -> "NumberContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: NumberContext for this NumberInstance
+        """
+        if self._context is None:
+            self._context = NumberContext(
+                self._version,
+                number=self._solution["number"],
+            )
+        return self._context
+
+    def fetch(self) -> "NumberInstance":
+        """
+        Fetch the NumberInstance
+
+
+        :returns: The fetched NumberInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "NumberInstance":
+        """
+        Asynchronous coroutine to fetch the NumberInstance
+
+
+        :returns: The fetched NumberInstance
+        """
+        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.Pricing.V1.NumberInstance {}>".format(context)
+
+
+class NumberContext(InstanceContext):
+    def __init__(self, version: Version, number: str):
+        """
+        Initialize the NumberContext
+
+        :param version: Version that contains the resource
+        :param number: The phone number to fetch.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "number": number,
+        }
+        self._uri = "/Voice/Numbers/{number}".format(**self._solution)
+
+    def fetch(self) -> NumberInstance:
+        """
+        Fetch the NumberInstance
+
+
+        :returns: The fetched NumberInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return NumberInstance(
+            self._version,
+            payload,
+            number=self._solution["number"],
+        )
+
+    async def fetch_async(self) -> NumberInstance:
+        """
+        Asynchronous coroutine to fetch the NumberInstance
+
+
+        :returns: The fetched NumberInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return NumberInstance(
+            self._version,
+            payload,
+            number=self._solution["number"],
+        )
+
+    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.Pricing.V1.NumberContext {}>".format(context)
+
+
+class NumberList(ListResource):
+    def __init__(self, version: Version):
+        """
+        Initialize the NumberList
+
+        :param version: Version that contains the resource
+
+        """
+        super().__init__(version)
+
+    def get(self, number: str) -> NumberContext:
+        """
+        Constructs a NumberContext
+
+        :param number: The phone number to fetch.
+        """
+        return NumberContext(self._version, number=number)
+
+    def __call__(self, number: str) -> NumberContext:
+        """
+        Constructs a NumberContext
+
+        :param number: The phone number to fetch.
+        """
+        return NumberContext(self._version, number=number)
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Pricing.V1.NumberList>"