Initial commit: Email alerts application

venv/lib/python3.11/site-packages/twilio/rest/studio/StudioBase.py

@@ -0,0 +1,54 @@
+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.studio.v1 import V1
+from twilio.rest.studio.v2 import V2
+
+
+class StudioBase(Domain):
+    def __init__(self, twilio: Client):
+        """
+        Initialize the Studio Domain
+
+        :returns: Domain for Studio
+        """
+        super().__init__(twilio, "https://studio.twilio.com")
+        self._v1: Optional[V1] = None
+        self._v2: Optional[V2] = None
+
+    @property
+    def v1(self) -> V1:
+        """
+        :returns: Versions v1 of Studio
+        """
+        if self._v1 is None:
+            self._v1 = V1(self)
+        return self._v1
+
+    @property
+    def v2(self) -> V2:
+        """
+        :returns: Versions v2 of Studio
+        """
+        if self._v2 is None:
+            self._v2 = V2(self)
+        return self._v2
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio>"

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

@@ -0,0 +1,25 @@
+from warnings import warn
+
+from twilio.rest.studio.StudioBase import StudioBase
+from twilio.rest.studio.v2.flow import FlowList
+from twilio.rest.studio.v2.flow_validate import FlowValidateList
+
+
+class Studio(StudioBase):
+    @property
+    def flows(self) -> FlowList:
+        warn(
+            "flows is deprecated. Use v2.flows instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.v2.flows
+
+    @property
+    def flow_validate(self) -> FlowValidateList:
+        warn(
+            "flow_validate is deprecated. Use v2.flow_validate instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.v2.flow_validate

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

@@ -0,0 +1,42 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Studio
+    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.studio.v1.flow import FlowList
+
+
+class V1(Version):
+    def __init__(self, domain: Domain):
+        """
+        Initialize the V1 version of Studio
+
+        :param domain: The Twilio.studio domain
+        """
+        super().__init__(domain, "v1")
+        self._flows: Optional[FlowList] = None
+
+    @property
+    def flows(self) -> FlowList:
+        if self._flows is None:
+            self._flows = FlowList(self)
+        return self._flows
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V1>"

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

@@ -0,0 +1,494 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Studio
+    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.studio.v1.flow.engagement import EngagementList
+from twilio.rest.studio.v1.flow.execution import ExecutionList
+
+
+class FlowInstance(InstanceResource):
+    class Status(object):
+        DRAFT = "draft"
+        PUBLISHED = "published"
+
+    """
+    :ivar sid: The unique string that we created to identify the Flow resource.
+    :ivar account_sid: The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the Flow resource.
+    :ivar friendly_name: The string that you assigned to describe the Flow.
+    :ivar status: 
+    :ivar version: The latest version number of the Flow's definition.
+    :ivar date_created: The date and time in GMT when the resource was created specified in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
+    :ivar date_updated: The date and time in GMT when the resource was last updated specified in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
+    :ivar url: The absolute URL of the resource.
+    :ivar links: The URLs of the Flow's nested resources.
+    """
+
+    def __init__(
+        self, version: Version, payload: Dict[str, Any], sid: Optional[str] = None
+    ):
+        super().__init__(version)
+
+        self.sid: Optional[str] = payload.get("sid")
+        self.account_sid: Optional[str] = payload.get("account_sid")
+        self.friendly_name: Optional[str] = payload.get("friendly_name")
+        self.status: Optional["FlowInstance.Status"] = payload.get("status")
+        self.version: Optional[int] = deserialize.integer(payload.get("version"))
+        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.links: Optional[Dict[str, object]] = payload.get("links")
+
+        self._solution = {
+            "sid": sid or self.sid,
+        }
+        self._context: Optional[FlowContext] = None
+
+    @property
+    def _proxy(self) -> "FlowContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: FlowContext for this FlowInstance
+        """
+        if self._context is None:
+            self._context = FlowContext(
+                self._version,
+                sid=self._solution["sid"],
+            )
+        return self._context
+
+    def delete(self) -> bool:
+        """
+        Deletes the FlowInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return self._proxy.delete()
+
+    async def delete_async(self) -> bool:
+        """
+        Asynchronous coroutine that deletes the FlowInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return await self._proxy.delete_async()
+
+    def fetch(self) -> "FlowInstance":
+        """
+        Fetch the FlowInstance
+
+
+        :returns: The fetched FlowInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "FlowInstance":
+        """
+        Asynchronous coroutine to fetch the FlowInstance
+
+
+        :returns: The fetched FlowInstance
+        """
+        return await self._proxy.fetch_async()
+
+    @property
+    def engagements(self) -> EngagementList:
+        """
+        Access the engagements
+        """
+        return self._proxy.engagements
+
+    @property
+    def executions(self) -> ExecutionList:
+        """
+        Access the executions
+        """
+        return self._proxy.executions
+
+    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.Studio.V1.FlowInstance {}>".format(context)
+
+
+class FlowContext(InstanceContext):
+    def __init__(self, version: Version, sid: str):
+        """
+        Initialize the FlowContext
+
+        :param version: Version that contains the resource
+        :param sid: The SID of the Flow resource to fetch.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "sid": sid,
+        }
+        self._uri = "/Flows/{sid}".format(**self._solution)
+
+        self._engagements: Optional[EngagementList] = None
+        self._executions: Optional[ExecutionList] = None
+
+    def delete(self) -> bool:
+        """
+        Deletes the FlowInstance
+
+
+        :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 FlowInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return await self._version.delete_async(
+            method="DELETE",
+            uri=self._uri,
+        )
+
+    def fetch(self) -> FlowInstance:
+        """
+        Fetch the FlowInstance
+
+
+        :returns: The fetched FlowInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return FlowInstance(
+            self._version,
+            payload,
+            sid=self._solution["sid"],
+        )
+
+    async def fetch_async(self) -> FlowInstance:
+        """
+        Asynchronous coroutine to fetch the FlowInstance
+
+
+        :returns: The fetched FlowInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return FlowInstance(
+            self._version,
+            payload,
+            sid=self._solution["sid"],
+        )
+
+    @property
+    def engagements(self) -> EngagementList:
+        """
+        Access the engagements
+        """
+        if self._engagements is None:
+            self._engagements = EngagementList(
+                self._version,
+                self._solution["sid"],
+            )
+        return self._engagements
+
+    @property
+    def executions(self) -> ExecutionList:
+        """
+        Access the executions
+        """
+        if self._executions is None:
+            self._executions = ExecutionList(
+                self._version,
+                self._solution["sid"],
+            )
+        return self._executions
+
+    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.Studio.V1.FlowContext {}>".format(context)
+
+
+class FlowPage(Page):
+    def get_instance(self, payload: Dict[str, Any]) -> FlowInstance:
+        """
+        Build an instance of FlowInstance
+
+        :param payload: Payload response from the API
+        """
+        return FlowInstance(self._version, payload)
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V1.FlowPage>"
+
+
+class FlowList(ListResource):
+    def __init__(self, version: Version):
+        """
+        Initialize the FlowList
+
+        :param version: Version that contains the resource
+
+        """
+        super().__init__(version)
+
+        self._uri = "/Flows"
+
+    def stream(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> Iterator[FlowInstance]:
+        """
+        Streams FlowInstance 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[FlowInstance]:
+        """
+        Asynchronously streams FlowInstance 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[FlowInstance]:
+        """
+        Lists FlowInstance 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[FlowInstance]:
+        """
+        Asynchronously lists FlowInstance 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,
+    ) -> FlowPage:
+        """
+        Retrieve a single page of FlowInstance 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 FlowInstance
+        """
+        data = values.of(
+            {
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = self._version.page(method="GET", uri=self._uri, params=data)
+        return FlowPage(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,
+    ) -> FlowPage:
+        """
+        Asynchronously retrieve a single page of FlowInstance 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 FlowInstance
+        """
+        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 FlowPage(self._version, response)
+
+    def get_page(self, target_url: str) -> FlowPage:
+        """
+        Retrieve a specific page of FlowInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of FlowInstance
+        """
+        response = self._version.domain.twilio.request("GET", target_url)
+        return FlowPage(self._version, response)
+
+    async def get_page_async(self, target_url: str) -> FlowPage:
+        """
+        Asynchronously retrieve a specific page of FlowInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of FlowInstance
+        """
+        response = await self._version.domain.twilio.request_async("GET", target_url)
+        return FlowPage(self._version, response)
+
+    def get(self, sid: str) -> FlowContext:
+        """
+        Constructs a FlowContext
+
+        :param sid: The SID of the Flow resource to fetch.
+        """
+        return FlowContext(self._version, sid=sid)
+
+    def __call__(self, sid: str) -> FlowContext:
+        """
+        Constructs a FlowContext
+
+        :param sid: The SID of the Flow resource to fetch.
+        """
+        return FlowContext(self._version, sid=sid)
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V1.FlowList>"

venv/lib/python3.11/site-packages/twilio/rest/studio/v1/flow/engagement/__init__.py

@@ -0,0 +1,585 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Studio
+    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, serialize, 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.studio.v1.flow.engagement.engagement_context import (
+    EngagementContextList,
+)
+from twilio.rest.studio.v1.flow.engagement.step import StepList
+
+
+class EngagementInstance(InstanceResource):
+    class Status(object):
+        ACTIVE = "active"
+        ENDED = "ended"
+
+    """
+    :ivar sid: The unique string that we created to identify the Engagement resource.
+    :ivar account_sid: The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the Engagement resource.
+    :ivar flow_sid: The SID of the Flow.
+    :ivar contact_sid: The SID of the Contact.
+    :ivar contact_channel_address: The phone number, SIP address or Client identifier that triggered this Engagement. Phone numbers are in E.164 format (+16175551212). SIP addresses are formatted as `name@company.com`. Client identifiers are formatted `client:name`.
+    :ivar context: The current state of the execution flow. As your flow executes, we save the state in a flow context. Your widgets can access the data in the flow context as variables, either in configuration fields or in text areas as variable substitution.
+    :ivar status: 
+    :ivar date_created: The date and time in GMT when the Engagement was created in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
+    :ivar date_updated: The date and time in GMT when the Engagement was updated in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
+    :ivar url: The absolute URL of the resource.
+    :ivar links: The URLs of the Engagement's nested resources.
+    """
+
+    def __init__(
+        self,
+        version: Version,
+        payload: Dict[str, Any],
+        flow_sid: str,
+        sid: Optional[str] = None,
+    ):
+        super().__init__(version)
+
+        self.sid: Optional[str] = payload.get("sid")
+        self.account_sid: Optional[str] = payload.get("account_sid")
+        self.flow_sid: Optional[str] = payload.get("flow_sid")
+        self.contact_sid: Optional[str] = payload.get("contact_sid")
+        self.contact_channel_address: Optional[str] = payload.get(
+            "contact_channel_address"
+        )
+        self.context: Optional[Dict[str, object]] = payload.get("context")
+        self.status: Optional["EngagementInstance.Status"] = payload.get("status")
+        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.links: Optional[Dict[str, object]] = payload.get("links")
+
+        self._solution = {
+            "flow_sid": flow_sid,
+            "sid": sid or self.sid,
+        }
+        self._context: Optional[EngagementContext] = None
+
+    @property
+    def _proxy(self) -> "EngagementContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: EngagementContext for this EngagementInstance
+        """
+        if self._context is None:
+            self._context = EngagementContext(
+                self._version,
+                flow_sid=self._solution["flow_sid"],
+                sid=self._solution["sid"],
+            )
+        return self._context
+
+    def delete(self) -> bool:
+        """
+        Deletes the EngagementInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return self._proxy.delete()
+
+    async def delete_async(self) -> bool:
+        """
+        Asynchronous coroutine that deletes the EngagementInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return await self._proxy.delete_async()
+
+    def fetch(self) -> "EngagementInstance":
+        """
+        Fetch the EngagementInstance
+
+
+        :returns: The fetched EngagementInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "EngagementInstance":
+        """
+        Asynchronous coroutine to fetch the EngagementInstance
+
+
+        :returns: The fetched EngagementInstance
+        """
+        return await self._proxy.fetch_async()
+
+    @property
+    def engagement_context(self) -> EngagementContextList:
+        """
+        Access the engagement_context
+        """
+        return self._proxy.engagement_context
+
+    @property
+    def steps(self) -> StepList:
+        """
+        Access the steps
+        """
+        return self._proxy.steps
+
+    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.Studio.V1.EngagementInstance {}>".format(context)
+
+
+class EngagementContext(InstanceContext):
+    def __init__(self, version: Version, flow_sid: str, sid: str):
+        """
+        Initialize the EngagementContext
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow.
+        :param sid: The SID of the Engagement resource to fetch.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "sid": sid,
+        }
+        self._uri = "/Flows/{flow_sid}/Engagements/{sid}".format(**self._solution)
+
+        self._engagement_context: Optional[EngagementContextList] = None
+        self._steps: Optional[StepList] = None
+
+    def delete(self) -> bool:
+        """
+        Deletes the EngagementInstance
+
+
+        :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 EngagementInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return await self._version.delete_async(
+            method="DELETE",
+            uri=self._uri,
+        )
+
+    def fetch(self) -> EngagementInstance:
+        """
+        Fetch the EngagementInstance
+
+
+        :returns: The fetched EngagementInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return EngagementInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            sid=self._solution["sid"],
+        )
+
+    async def fetch_async(self) -> EngagementInstance:
+        """
+        Asynchronous coroutine to fetch the EngagementInstance
+
+
+        :returns: The fetched EngagementInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return EngagementInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            sid=self._solution["sid"],
+        )
+
+    @property
+    def engagement_context(self) -> EngagementContextList:
+        """
+        Access the engagement_context
+        """
+        if self._engagement_context is None:
+            self._engagement_context = EngagementContextList(
+                self._version,
+                self._solution["flow_sid"],
+                self._solution["sid"],
+            )
+        return self._engagement_context
+
+    @property
+    def steps(self) -> StepList:
+        """
+        Access the steps
+        """
+        if self._steps is None:
+            self._steps = StepList(
+                self._version,
+                self._solution["flow_sid"],
+                self._solution["sid"],
+            )
+        return self._steps
+
+    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.Studio.V1.EngagementContext {}>".format(context)
+
+
+class EngagementPage(Page):
+    def get_instance(self, payload: Dict[str, Any]) -> EngagementInstance:
+        """
+        Build an instance of EngagementInstance
+
+        :param payload: Payload response from the API
+        """
+        return EngagementInstance(
+            self._version, payload, flow_sid=self._solution["flow_sid"]
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V1.EngagementPage>"
+
+
+class EngagementList(ListResource):
+    def __init__(self, version: Version, flow_sid: str):
+        """
+        Initialize the EngagementList
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow to read Engagements from.
+
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+        }
+        self._uri = "/Flows/{flow_sid}/Engagements".format(**self._solution)
+
+    def create(
+        self, to: str, from_: str, parameters: Union[object, object] = values.unset
+    ) -> EngagementInstance:
+        """
+        Create the EngagementInstance
+
+        :param to: The Contact phone number to start a Studio Flow Engagement, available as variable `{{contact.channel.address}}`.
+        :param from_: The Twilio phone number to send messages or initiate calls from during the Flow Engagement. Available as variable `{{flow.channel.address}}`
+        :param parameters: A JSON string we will add to your flow's context and that you can access as variables inside your flow. For example, if you pass in `Parameters={'name':'Zeke'}` then inside a widget you can reference the variable `{{flow.data.name}}` which will return the string 'Zeke'. Note: the JSON value must explicitly be passed as a string, not as a hash object. Depending on your particular HTTP library, you may need to add quotes or URL encode your JSON string.
+
+        :returns: The created EngagementInstance
+        """
+        data = values.of(
+            {
+                "To": to,
+                "From": from_,
+                "Parameters": serialize.object(parameters),
+            }
+        )
+
+        payload = self._version.create(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return EngagementInstance(
+            self._version, payload, flow_sid=self._solution["flow_sid"]
+        )
+
+    async def create_async(
+        self, to: str, from_: str, parameters: Union[object, object] = values.unset
+    ) -> EngagementInstance:
+        """
+        Asynchronously create the EngagementInstance
+
+        :param to: The Contact phone number to start a Studio Flow Engagement, available as variable `{{contact.channel.address}}`.
+        :param from_: The Twilio phone number to send messages or initiate calls from during the Flow Engagement. Available as variable `{{flow.channel.address}}`
+        :param parameters: A JSON string we will add to your flow's context and that you can access as variables inside your flow. For example, if you pass in `Parameters={'name':'Zeke'}` then inside a widget you can reference the variable `{{flow.data.name}}` which will return the string 'Zeke'. Note: the JSON value must explicitly be passed as a string, not as a hash object. Depending on your particular HTTP library, you may need to add quotes or URL encode your JSON string.
+
+        :returns: The created EngagementInstance
+        """
+        data = values.of(
+            {
+                "To": to,
+                "From": from_,
+                "Parameters": serialize.object(parameters),
+            }
+        )
+
+        payload = await self._version.create_async(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return EngagementInstance(
+            self._version, payload, flow_sid=self._solution["flow_sid"]
+        )
+
+    def stream(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> Iterator[EngagementInstance]:
+        """
+        Streams EngagementInstance 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[EngagementInstance]:
+        """
+        Asynchronously streams EngagementInstance 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[EngagementInstance]:
+        """
+        Lists EngagementInstance 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[EngagementInstance]:
+        """
+        Asynchronously lists EngagementInstance 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,
+    ) -> EngagementPage:
+        """
+        Retrieve a single page of EngagementInstance 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 EngagementInstance
+        """
+        data = values.of(
+            {
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = self._version.page(method="GET", uri=self._uri, params=data)
+        return EngagementPage(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,
+    ) -> EngagementPage:
+        """
+        Asynchronously retrieve a single page of EngagementInstance 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 EngagementInstance
+        """
+        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 EngagementPage(self._version, response, self._solution)
+
+    def get_page(self, target_url: str) -> EngagementPage:
+        """
+        Retrieve a specific page of EngagementInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of EngagementInstance
+        """
+        response = self._version.domain.twilio.request("GET", target_url)
+        return EngagementPage(self._version, response, self._solution)
+
+    async def get_page_async(self, target_url: str) -> EngagementPage:
+        """
+        Asynchronously retrieve a specific page of EngagementInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of EngagementInstance
+        """
+        response = await self._version.domain.twilio.request_async("GET", target_url)
+        return EngagementPage(self._version, response, self._solution)
+
+    def get(self, sid: str) -> EngagementContext:
+        """
+        Constructs a EngagementContext
+
+        :param sid: The SID of the Engagement resource to fetch.
+        """
+        return EngagementContext(
+            self._version, flow_sid=self._solution["flow_sid"], sid=sid
+        )
+
+    def __call__(self, sid: str) -> EngagementContext:
+        """
+        Constructs a EngagementContext
+
+        :param sid: The SID of the Engagement resource to fetch.
+        """
+        return EngagementContext(
+            self._version, flow_sid=self._solution["flow_sid"], sid=sid
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V1.EngagementList>"

venv/lib/python3.11/site-packages/twilio/rest/studio/v1/flow/engagement/engagement_context.py

@@ -0,0 +1,214 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Studio
+    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 EngagementContextInstance(InstanceResource):
+
+    """
+    :ivar account_sid: The SID of the Account.
+    :ivar context: As your flow executes, we save the state in what's called the Flow Context. Any data in the flow context can be accessed by your widgets as variables, either in configuration fields or in text areas as variable substitution.
+    :ivar engagement_sid: The SID of the Engagement.
+    :ivar flow_sid: The SID of the Flow.
+    :ivar url: The URL of the resource.
+    """
+
+    def __init__(
+        self,
+        version: Version,
+        payload: Dict[str, Any],
+        flow_sid: str,
+        engagement_sid: str,
+    ):
+        super().__init__(version)
+
+        self.account_sid: Optional[str] = payload.get("account_sid")
+        self.context: Optional[Dict[str, object]] = payload.get("context")
+        self.engagement_sid: Optional[str] = payload.get("engagement_sid")
+        self.flow_sid: Optional[str] = payload.get("flow_sid")
+        self.url: Optional[str] = payload.get("url")
+
+        self._solution = {
+            "flow_sid": flow_sid,
+            "engagement_sid": engagement_sid,
+        }
+        self._context: Optional[EngagementContextContext] = None
+
+    @property
+    def _proxy(self) -> "EngagementContextContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: EngagementContextContext for this EngagementContextInstance
+        """
+        if self._context is None:
+            self._context = EngagementContextContext(
+                self._version,
+                flow_sid=self._solution["flow_sid"],
+                engagement_sid=self._solution["engagement_sid"],
+            )
+        return self._context
+
+    def fetch(self) -> "EngagementContextInstance":
+        """
+        Fetch the EngagementContextInstance
+
+
+        :returns: The fetched EngagementContextInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "EngagementContextInstance":
+        """
+        Asynchronous coroutine to fetch the EngagementContextInstance
+
+
+        :returns: The fetched EngagementContextInstance
+        """
+        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.Studio.V1.EngagementContextInstance {}>".format(context)
+
+
+class EngagementContextContext(InstanceContext):
+    def __init__(self, version: Version, flow_sid: str, engagement_sid: str):
+        """
+        Initialize the EngagementContextContext
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow.
+        :param engagement_sid: The SID of the Engagement.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "engagement_sid": engagement_sid,
+        }
+        self._uri = "/Flows/{flow_sid}/Engagements/{engagement_sid}/Context".format(
+            **self._solution
+        )
+
+    def fetch(self) -> EngagementContextInstance:
+        """
+        Fetch the EngagementContextInstance
+
+
+        :returns: The fetched EngagementContextInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return EngagementContextInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            engagement_sid=self._solution["engagement_sid"],
+        )
+
+    async def fetch_async(self) -> EngagementContextInstance:
+        """
+        Asynchronous coroutine to fetch the EngagementContextInstance
+
+
+        :returns: The fetched EngagementContextInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return EngagementContextInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            engagement_sid=self._solution["engagement_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.Studio.V1.EngagementContextContext {}>".format(context)
+
+
+class EngagementContextList(ListResource):
+    def __init__(self, version: Version, flow_sid: str, engagement_sid: str):
+        """
+        Initialize the EngagementContextList
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow.
+        :param engagement_sid: The SID of the Engagement.
+
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "engagement_sid": engagement_sid,
+        }
+
+    def get(self) -> EngagementContextContext:
+        """
+        Constructs a EngagementContextContext
+
+        """
+        return EngagementContextContext(
+            self._version,
+            flow_sid=self._solution["flow_sid"],
+            engagement_sid=self._solution["engagement_sid"],
+        )
+
+    def __call__(self) -> EngagementContextContext:
+        """
+        Constructs a EngagementContextContext
+
+        """
+        return EngagementContextContext(
+            self._version,
+            flow_sid=self._solution["flow_sid"],
+            engagement_sid=self._solution["engagement_sid"],
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V1.EngagementContextList>"

venv/lib/python3.11/site-packages/twilio/rest/studio/v1/flow/engagement/step/__init__.py

@@ -0,0 +1,479 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Studio
+    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.studio.v1.flow.engagement.step.step_context import StepContextList
+
+
+class StepInstance(InstanceResource):
+
+    """
+    :ivar sid: The unique string that we created to identify the Step resource.
+    :ivar account_sid: The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the Step resource.
+    :ivar flow_sid: The SID of the Flow.
+    :ivar engagement_sid: The SID of the Engagement.
+    :ivar name: The event that caused the Flow to transition to the Step.
+    :ivar context: The current state of the Flow's Execution. As a flow executes, we save its state in this context. We save data that your widgets can access as variables in configuration fields or in text areas as variable substitution.
+    :ivar transitioned_from: The Widget that preceded the Widget for the Step.
+    :ivar transitioned_to: The Widget that will follow the Widget for the Step.
+    :ivar date_created: The date and time in GMT when the resource was created specified in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
+    :ivar date_updated: The date and time in GMT when the resource was last updated specified in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
+    :ivar url: The absolute URL of the resource.
+    :ivar links: The URLs of related resources.
+    """
+
+    def __init__(
+        self,
+        version: Version,
+        payload: Dict[str, Any],
+        flow_sid: str,
+        engagement_sid: str,
+        sid: Optional[str] = None,
+    ):
+        super().__init__(version)
+
+        self.sid: Optional[str] = payload.get("sid")
+        self.account_sid: Optional[str] = payload.get("account_sid")
+        self.flow_sid: Optional[str] = payload.get("flow_sid")
+        self.engagement_sid: Optional[str] = payload.get("engagement_sid")
+        self.name: Optional[str] = payload.get("name")
+        self.context: Optional[Dict[str, object]] = payload.get("context")
+        self.transitioned_from: Optional[str] = payload.get("transitioned_from")
+        self.transitioned_to: Optional[str] = payload.get("transitioned_to")
+        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.links: Optional[Dict[str, object]] = payload.get("links")
+
+        self._solution = {
+            "flow_sid": flow_sid,
+            "engagement_sid": engagement_sid,
+            "sid": sid or self.sid,
+        }
+        self._context: Optional[StepContext] = None
+
+    @property
+    def _proxy(self) -> "StepContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: StepContext for this StepInstance
+        """
+        if self._context is None:
+            self._context = StepContext(
+                self._version,
+                flow_sid=self._solution["flow_sid"],
+                engagement_sid=self._solution["engagement_sid"],
+                sid=self._solution["sid"],
+            )
+        return self._context
+
+    def fetch(self) -> "StepInstance":
+        """
+        Fetch the StepInstance
+
+
+        :returns: The fetched StepInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "StepInstance":
+        """
+        Asynchronous coroutine to fetch the StepInstance
+
+
+        :returns: The fetched StepInstance
+        """
+        return await self._proxy.fetch_async()
+
+    @property
+    def step_context(self) -> StepContextList:
+        """
+        Access the step_context
+        """
+        return self._proxy.step_context
+
+    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.Studio.V1.StepInstance {}>".format(context)
+
+
+class StepContext(InstanceContext):
+    def __init__(self, version: Version, flow_sid: str, engagement_sid: str, sid: str):
+        """
+        Initialize the StepContext
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow with the Step to fetch.
+        :param engagement_sid: The SID of the Engagement with the Step to fetch.
+        :param sid: The SID of the Step resource to fetch.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "engagement_sid": engagement_sid,
+            "sid": sid,
+        }
+        self._uri = "/Flows/{flow_sid}/Engagements/{engagement_sid}/Steps/{sid}".format(
+            **self._solution
+        )
+
+        self._step_context: Optional[StepContextList] = None
+
+    def fetch(self) -> StepInstance:
+        """
+        Fetch the StepInstance
+
+
+        :returns: The fetched StepInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return StepInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            engagement_sid=self._solution["engagement_sid"],
+            sid=self._solution["sid"],
+        )
+
+    async def fetch_async(self) -> StepInstance:
+        """
+        Asynchronous coroutine to fetch the StepInstance
+
+
+        :returns: The fetched StepInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return StepInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            engagement_sid=self._solution["engagement_sid"],
+            sid=self._solution["sid"],
+        )
+
+    @property
+    def step_context(self) -> StepContextList:
+        """
+        Access the step_context
+        """
+        if self._step_context is None:
+            self._step_context = StepContextList(
+                self._version,
+                self._solution["flow_sid"],
+                self._solution["engagement_sid"],
+                self._solution["sid"],
+            )
+        return self._step_context
+
+    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.Studio.V1.StepContext {}>".format(context)
+
+
+class StepPage(Page):
+    def get_instance(self, payload: Dict[str, Any]) -> StepInstance:
+        """
+        Build an instance of StepInstance
+
+        :param payload: Payload response from the API
+        """
+        return StepInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            engagement_sid=self._solution["engagement_sid"],
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V1.StepPage>"
+
+
+class StepList(ListResource):
+    def __init__(self, version: Version, flow_sid: str, engagement_sid: str):
+        """
+        Initialize the StepList
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow with the Step to read.
+        :param engagement_sid: The SID of the Engagement with the Step to read.
+
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "engagement_sid": engagement_sid,
+        }
+        self._uri = "/Flows/{flow_sid}/Engagements/{engagement_sid}/Steps".format(
+            **self._solution
+        )
+
+    def stream(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> Iterator[StepInstance]:
+        """
+        Streams StepInstance 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[StepInstance]:
+        """
+        Asynchronously streams StepInstance 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[StepInstance]:
+        """
+        Lists StepInstance 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[StepInstance]:
+        """
+        Asynchronously lists StepInstance 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,
+    ) -> StepPage:
+        """
+        Retrieve a single page of StepInstance 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 StepInstance
+        """
+        data = values.of(
+            {
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = self._version.page(method="GET", uri=self._uri, params=data)
+        return StepPage(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,
+    ) -> StepPage:
+        """
+        Asynchronously retrieve a single page of StepInstance 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 StepInstance
+        """
+        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 StepPage(self._version, response, self._solution)
+
+    def get_page(self, target_url: str) -> StepPage:
+        """
+        Retrieve a specific page of StepInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of StepInstance
+        """
+        response = self._version.domain.twilio.request("GET", target_url)
+        return StepPage(self._version, response, self._solution)
+
+    async def get_page_async(self, target_url: str) -> StepPage:
+        """
+        Asynchronously retrieve a specific page of StepInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of StepInstance
+        """
+        response = await self._version.domain.twilio.request_async("GET", target_url)
+        return StepPage(self._version, response, self._solution)
+
+    def get(self, sid: str) -> StepContext:
+        """
+        Constructs a StepContext
+
+        :param sid: The SID of the Step resource to fetch.
+        """
+        return StepContext(
+            self._version,
+            flow_sid=self._solution["flow_sid"],
+            engagement_sid=self._solution["engagement_sid"],
+            sid=sid,
+        )
+
+    def __call__(self, sid: str) -> StepContext:
+        """
+        Constructs a StepContext
+
+        :param sid: The SID of the Step resource to fetch.
+        """
+        return StepContext(
+            self._version,
+            flow_sid=self._solution["flow_sid"],
+            engagement_sid=self._solution["engagement_sid"],
+            sid=sid,
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V1.StepList>"

venv/lib/python3.11/site-packages/twilio/rest/studio/v1/flow/engagement/step/step_context.py

@@ -0,0 +1,231 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Studio
+    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 StepContextInstance(InstanceResource):
+
+    """
+    :ivar account_sid: The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the StepContext resource.
+    :ivar context: The current state of the Flow's Execution. As a flow executes, we save its state in this context. We save data that your widgets can access as variables in configuration fields or in text areas as variable substitution.
+    :ivar engagement_sid: The SID of the Engagement.
+    :ivar flow_sid: The SID of the Flow.
+    :ivar step_sid: The SID of the Step the context is associated with.
+    :ivar url: The absolute URL of the resource.
+    """
+
+    def __init__(
+        self,
+        version: Version,
+        payload: Dict[str, Any],
+        flow_sid: str,
+        engagement_sid: str,
+        step_sid: str,
+    ):
+        super().__init__(version)
+
+        self.account_sid: Optional[str] = payload.get("account_sid")
+        self.context: Optional[Dict[str, object]] = payload.get("context")
+        self.engagement_sid: Optional[str] = payload.get("engagement_sid")
+        self.flow_sid: Optional[str] = payload.get("flow_sid")
+        self.step_sid: Optional[str] = payload.get("step_sid")
+        self.url: Optional[str] = payload.get("url")
+
+        self._solution = {
+            "flow_sid": flow_sid,
+            "engagement_sid": engagement_sid,
+            "step_sid": step_sid,
+        }
+        self._context: Optional[StepContextContext] = None
+
+    @property
+    def _proxy(self) -> "StepContextContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: StepContextContext for this StepContextInstance
+        """
+        if self._context is None:
+            self._context = StepContextContext(
+                self._version,
+                flow_sid=self._solution["flow_sid"],
+                engagement_sid=self._solution["engagement_sid"],
+                step_sid=self._solution["step_sid"],
+            )
+        return self._context
+
+    def fetch(self) -> "StepContextInstance":
+        """
+        Fetch the StepContextInstance
+
+
+        :returns: The fetched StepContextInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "StepContextInstance":
+        """
+        Asynchronous coroutine to fetch the StepContextInstance
+
+
+        :returns: The fetched StepContextInstance
+        """
+        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.Studio.V1.StepContextInstance {}>".format(context)
+
+
+class StepContextContext(InstanceContext):
+    def __init__(
+        self, version: Version, flow_sid: str, engagement_sid: str, step_sid: str
+    ):
+        """
+        Initialize the StepContextContext
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow with the Step to fetch.
+        :param engagement_sid: The SID of the Engagement with the Step to fetch.
+        :param step_sid: The SID of the Step to fetch
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "engagement_sid": engagement_sid,
+            "step_sid": step_sid,
+        }
+        self._uri = "/Flows/{flow_sid}/Engagements/{engagement_sid}/Steps/{step_sid}/Context".format(
+            **self._solution
+        )
+
+    def fetch(self) -> StepContextInstance:
+        """
+        Fetch the StepContextInstance
+
+
+        :returns: The fetched StepContextInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return StepContextInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            engagement_sid=self._solution["engagement_sid"],
+            step_sid=self._solution["step_sid"],
+        )
+
+    async def fetch_async(self) -> StepContextInstance:
+        """
+        Asynchronous coroutine to fetch the StepContextInstance
+
+
+        :returns: The fetched StepContextInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return StepContextInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            engagement_sid=self._solution["engagement_sid"],
+            step_sid=self._solution["step_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.Studio.V1.StepContextContext {}>".format(context)
+
+
+class StepContextList(ListResource):
+    def __init__(
+        self, version: Version, flow_sid: str, engagement_sid: str, step_sid: str
+    ):
+        """
+        Initialize the StepContextList
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow with the Step to fetch.
+        :param engagement_sid: The SID of the Engagement with the Step to fetch.
+        :param step_sid: The SID of the Step to fetch
+
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "engagement_sid": engagement_sid,
+            "step_sid": step_sid,
+        }
+
+    def get(self) -> StepContextContext:
+        """
+        Constructs a StepContextContext
+
+        """
+        return StepContextContext(
+            self._version,
+            flow_sid=self._solution["flow_sid"],
+            engagement_sid=self._solution["engagement_sid"],
+            step_sid=self._solution["step_sid"],
+        )
+
+    def __call__(self) -> StepContextContext:
+        """
+        Constructs a StepContextContext
+
+        """
+        return StepContextContext(
+            self._version,
+            flow_sid=self._solution["flow_sid"],
+            engagement_sid=self._solution["engagement_sid"],
+            step_sid=self._solution["step_sid"],
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V1.StepContextList>"

venv/lib/python3.11/site-packages/twilio/rest/studio/v1/flow/execution/__init__.py

@@ -0,0 +1,705 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Studio
+    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, serialize, 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.studio.v1.flow.execution.execution_context import ExecutionContextList
+from twilio.rest.studio.v1.flow.execution.execution_step import ExecutionStepList
+
+
+class ExecutionInstance(InstanceResource):
+    class Status(object):
+        ACTIVE = "active"
+        ENDED = "ended"
+
+    """
+    :ivar sid: The unique string that we created to identify the Execution resource.
+    :ivar account_sid: The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the Execution resource.
+    :ivar flow_sid: The SID of the Flow.
+    :ivar contact_sid: The SID of the Contact.
+    :ivar contact_channel_address: The phone number, SIP address or Client identifier that triggered the Execution. Phone numbers are in E.164 format (e.g. +16175551212). SIP addresses are formatted as `name@company.com`. Client identifiers are formatted `client:name`.
+    :ivar context: The current state of the Flow's Execution. As a flow executes, we save its state in this context. We save data that your widgets can access as variables in configuration fields or in text areas as variable substitution.
+    :ivar status: 
+    :ivar date_created: The date and time in GMT when the resource was created specified in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
+    :ivar date_updated: The date and time in GMT when the resource was last updated specified in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
+    :ivar url: The absolute URL of the resource.
+    :ivar links: The URLs of nested resources.
+    """
+
+    def __init__(
+        self,
+        version: Version,
+        payload: Dict[str, Any],
+        flow_sid: str,
+        sid: Optional[str] = None,
+    ):
+        super().__init__(version)
+
+        self.sid: Optional[str] = payload.get("sid")
+        self.account_sid: Optional[str] = payload.get("account_sid")
+        self.flow_sid: Optional[str] = payload.get("flow_sid")
+        self.contact_sid: Optional[str] = payload.get("contact_sid")
+        self.contact_channel_address: Optional[str] = payload.get(
+            "contact_channel_address"
+        )
+        self.context: Optional[Dict[str, object]] = payload.get("context")
+        self.status: Optional["ExecutionInstance.Status"] = payload.get("status")
+        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.links: Optional[Dict[str, object]] = payload.get("links")
+
+        self._solution = {
+            "flow_sid": flow_sid,
+            "sid": sid or self.sid,
+        }
+        self._context: Optional[ExecutionContext] = None
+
+    @property
+    def _proxy(self) -> "ExecutionContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: ExecutionContext for this ExecutionInstance
+        """
+        if self._context is None:
+            self._context = ExecutionContext(
+                self._version,
+                flow_sid=self._solution["flow_sid"],
+                sid=self._solution["sid"],
+            )
+        return self._context
+
+    def delete(self) -> bool:
+        """
+        Deletes the ExecutionInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return self._proxy.delete()
+
+    async def delete_async(self) -> bool:
+        """
+        Asynchronous coroutine that deletes the ExecutionInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return await self._proxy.delete_async()
+
+    def fetch(self) -> "ExecutionInstance":
+        """
+        Fetch the ExecutionInstance
+
+
+        :returns: The fetched ExecutionInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "ExecutionInstance":
+        """
+        Asynchronous coroutine to fetch the ExecutionInstance
+
+
+        :returns: The fetched ExecutionInstance
+        """
+        return await self._proxy.fetch_async()
+
+    def update(self, status: "ExecutionInstance.Status") -> "ExecutionInstance":
+        """
+        Update the ExecutionInstance
+
+        :param status:
+
+        :returns: The updated ExecutionInstance
+        """
+        return self._proxy.update(
+            status=status,
+        )
+
+    async def update_async(
+        self, status: "ExecutionInstance.Status"
+    ) -> "ExecutionInstance":
+        """
+        Asynchronous coroutine to update the ExecutionInstance
+
+        :param status:
+
+        :returns: The updated ExecutionInstance
+        """
+        return await self._proxy.update_async(
+            status=status,
+        )
+
+    @property
+    def execution_context(self) -> ExecutionContextList:
+        """
+        Access the execution_context
+        """
+        return self._proxy.execution_context
+
+    @property
+    def steps(self) -> ExecutionStepList:
+        """
+        Access the steps
+        """
+        return self._proxy.steps
+
+    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.Studio.V1.ExecutionInstance {}>".format(context)
+
+
+class ExecutionContext(InstanceContext):
+    def __init__(self, version: Version, flow_sid: str, sid: str):
+        """
+        Initialize the ExecutionContext
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow with the Execution resources to update.
+        :param sid: The SID of the Execution resource to update.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "sid": sid,
+        }
+        self._uri = "/Flows/{flow_sid}/Executions/{sid}".format(**self._solution)
+
+        self._execution_context: Optional[ExecutionContextList] = None
+        self._steps: Optional[ExecutionStepList] = None
+
+    def delete(self) -> bool:
+        """
+        Deletes the ExecutionInstance
+
+
+        :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 ExecutionInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return await self._version.delete_async(
+            method="DELETE",
+            uri=self._uri,
+        )
+
+    def fetch(self) -> ExecutionInstance:
+        """
+        Fetch the ExecutionInstance
+
+
+        :returns: The fetched ExecutionInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return ExecutionInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            sid=self._solution["sid"],
+        )
+
+    async def fetch_async(self) -> ExecutionInstance:
+        """
+        Asynchronous coroutine to fetch the ExecutionInstance
+
+
+        :returns: The fetched ExecutionInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return ExecutionInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            sid=self._solution["sid"],
+        )
+
+    def update(self, status: "ExecutionInstance.Status") -> ExecutionInstance:
+        """
+        Update the ExecutionInstance
+
+        :param status:
+
+        :returns: The updated ExecutionInstance
+        """
+        data = values.of(
+            {
+                "Status": status,
+            }
+        )
+
+        payload = self._version.update(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return ExecutionInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            sid=self._solution["sid"],
+        )
+
+    async def update_async(
+        self, status: "ExecutionInstance.Status"
+    ) -> ExecutionInstance:
+        """
+        Asynchronous coroutine to update the ExecutionInstance
+
+        :param status:
+
+        :returns: The updated ExecutionInstance
+        """
+        data = values.of(
+            {
+                "Status": status,
+            }
+        )
+
+        payload = await self._version.update_async(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return ExecutionInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            sid=self._solution["sid"],
+        )
+
+    @property
+    def execution_context(self) -> ExecutionContextList:
+        """
+        Access the execution_context
+        """
+        if self._execution_context is None:
+            self._execution_context = ExecutionContextList(
+                self._version,
+                self._solution["flow_sid"],
+                self._solution["sid"],
+            )
+        return self._execution_context
+
+    @property
+    def steps(self) -> ExecutionStepList:
+        """
+        Access the steps
+        """
+        if self._steps is None:
+            self._steps = ExecutionStepList(
+                self._version,
+                self._solution["flow_sid"],
+                self._solution["sid"],
+            )
+        return self._steps
+
+    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.Studio.V1.ExecutionContext {}>".format(context)
+
+
+class ExecutionPage(Page):
+    def get_instance(self, payload: Dict[str, Any]) -> ExecutionInstance:
+        """
+        Build an instance of ExecutionInstance
+
+        :param payload: Payload response from the API
+        """
+        return ExecutionInstance(
+            self._version, payload, flow_sid=self._solution["flow_sid"]
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V1.ExecutionPage>"
+
+
+class ExecutionList(ListResource):
+    def __init__(self, version: Version, flow_sid: str):
+        """
+        Initialize the ExecutionList
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow with the Execution resources to read.
+
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+        }
+        self._uri = "/Flows/{flow_sid}/Executions".format(**self._solution)
+
+    def create(
+        self, to: str, from_: str, parameters: Union[object, object] = values.unset
+    ) -> ExecutionInstance:
+        """
+        Create the ExecutionInstance
+
+        :param to: The Contact phone number to start a Studio Flow Execution, available as variable `{{contact.channel.address}}`.
+        :param from_: The Twilio phone number to send messages or initiate calls from during the Flow's Execution. Available as variable `{{flow.channel.address}}`. For SMS, this can also be a Messaging Service SID.
+        :param parameters: JSON data that will be added to the Flow's context and that can be accessed as variables inside your Flow. For example, if you pass in `Parameters={\\\"name\\\":\\\"Zeke\\\"}`, a widget in your Flow can reference the variable `{{flow.data.name}}`, which returns \\\"Zeke\\\". Note: the JSON value must explicitly be passed as a string, not as a hash object. Depending on your particular HTTP library, you may need to add quotes or URL encode the JSON string.
+
+        :returns: The created ExecutionInstance
+        """
+        data = values.of(
+            {
+                "To": to,
+                "From": from_,
+                "Parameters": serialize.object(parameters),
+            }
+        )
+
+        payload = self._version.create(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return ExecutionInstance(
+            self._version, payload, flow_sid=self._solution["flow_sid"]
+        )
+
+    async def create_async(
+        self, to: str, from_: str, parameters: Union[object, object] = values.unset
+    ) -> ExecutionInstance:
+        """
+        Asynchronously create the ExecutionInstance
+
+        :param to: The Contact phone number to start a Studio Flow Execution, available as variable `{{contact.channel.address}}`.
+        :param from_: The Twilio phone number to send messages or initiate calls from during the Flow's Execution. Available as variable `{{flow.channel.address}}`. For SMS, this can also be a Messaging Service SID.
+        :param parameters: JSON data that will be added to the Flow's context and that can be accessed as variables inside your Flow. For example, if you pass in `Parameters={\\\"name\\\":\\\"Zeke\\\"}`, a widget in your Flow can reference the variable `{{flow.data.name}}`, which returns \\\"Zeke\\\". Note: the JSON value must explicitly be passed as a string, not as a hash object. Depending on your particular HTTP library, you may need to add quotes or URL encode the JSON string.
+
+        :returns: The created ExecutionInstance
+        """
+        data = values.of(
+            {
+                "To": to,
+                "From": from_,
+                "Parameters": serialize.object(parameters),
+            }
+        )
+
+        payload = await self._version.create_async(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return ExecutionInstance(
+            self._version, payload, flow_sid=self._solution["flow_sid"]
+        )
+
+    def stream(
+        self,
+        date_created_from: Union[datetime, object] = values.unset,
+        date_created_to: Union[datetime, object] = values.unset,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> Iterator[ExecutionInstance]:
+        """
+        Streams ExecutionInstance 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 datetime date_created_from: Only show Execution resources starting on or after this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :param datetime date_created_to: Only show Execution resources starting before this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :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(
+            date_created_from=date_created_from,
+            date_created_to=date_created_to,
+            page_size=limits["page_size"],
+        )
+
+        return self._version.stream(page, limits["limit"])
+
+    async def stream_async(
+        self,
+        date_created_from: Union[datetime, object] = values.unset,
+        date_created_to: Union[datetime, object] = values.unset,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> AsyncIterator[ExecutionInstance]:
+        """
+        Asynchronously streams ExecutionInstance 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 datetime date_created_from: Only show Execution resources starting on or after this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :param datetime date_created_to: Only show Execution resources starting before this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :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(
+            date_created_from=date_created_from,
+            date_created_to=date_created_to,
+            page_size=limits["page_size"],
+        )
+
+        return self._version.stream_async(page, limits["limit"])
+
+    def list(
+        self,
+        date_created_from: Union[datetime, object] = values.unset,
+        date_created_to: Union[datetime, object] = values.unset,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> List[ExecutionInstance]:
+        """
+        Lists ExecutionInstance records from the API as a list.
+        Unlike stream(), this operation is eager and will load `limit` records into
+        memory before returning.
+
+        :param datetime date_created_from: Only show Execution resources starting on or after this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :param datetime date_created_to: Only show Execution resources starting before this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :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(
+                date_created_from=date_created_from,
+                date_created_to=date_created_to,
+                limit=limit,
+                page_size=page_size,
+            )
+        )
+
+    async def list_async(
+        self,
+        date_created_from: Union[datetime, object] = values.unset,
+        date_created_to: Union[datetime, object] = values.unset,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> List[ExecutionInstance]:
+        """
+        Asynchronously lists ExecutionInstance records from the API as a list.
+        Unlike stream(), this operation is eager and will load `limit` records into
+        memory before returning.
+
+        :param datetime date_created_from: Only show Execution resources starting on or after this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :param datetime date_created_to: Only show Execution resources starting before this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :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(
+                date_created_from=date_created_from,
+                date_created_to=date_created_to,
+                limit=limit,
+                page_size=page_size,
+            )
+        ]
+
+    def page(
+        self,
+        date_created_from: Union[datetime, object] = values.unset,
+        date_created_to: Union[datetime, object] = values.unset,
+        page_token: Union[str, object] = values.unset,
+        page_number: Union[int, object] = values.unset,
+        page_size: Union[int, object] = values.unset,
+    ) -> ExecutionPage:
+        """
+        Retrieve a single page of ExecutionInstance records from the API.
+        Request is executed immediately
+
+        :param date_created_from: Only show Execution resources starting on or after this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :param date_created_to: Only show Execution resources starting before this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :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 ExecutionInstance
+        """
+        data = values.of(
+            {
+                "DateCreatedFrom": serialize.iso8601_datetime(date_created_from),
+                "DateCreatedTo": serialize.iso8601_datetime(date_created_to),
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = self._version.page(method="GET", uri=self._uri, params=data)
+        return ExecutionPage(self._version, response, self._solution)
+
+    async def page_async(
+        self,
+        date_created_from: Union[datetime, object] = values.unset,
+        date_created_to: Union[datetime, object] = values.unset,
+        page_token: Union[str, object] = values.unset,
+        page_number: Union[int, object] = values.unset,
+        page_size: Union[int, object] = values.unset,
+    ) -> ExecutionPage:
+        """
+        Asynchronously retrieve a single page of ExecutionInstance records from the API.
+        Request is executed immediately
+
+        :param date_created_from: Only show Execution resources starting on or after this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :param date_created_to: Only show Execution resources starting before this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :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 ExecutionInstance
+        """
+        data = values.of(
+            {
+                "DateCreatedFrom": serialize.iso8601_datetime(date_created_from),
+                "DateCreatedTo": serialize.iso8601_datetime(date_created_to),
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = await self._version.page_async(
+            method="GET", uri=self._uri, params=data
+        )
+        return ExecutionPage(self._version, response, self._solution)
+
+    def get_page(self, target_url: str) -> ExecutionPage:
+        """
+        Retrieve a specific page of ExecutionInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of ExecutionInstance
+        """
+        response = self._version.domain.twilio.request("GET", target_url)
+        return ExecutionPage(self._version, response, self._solution)
+
+    async def get_page_async(self, target_url: str) -> ExecutionPage:
+        """
+        Asynchronously retrieve a specific page of ExecutionInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of ExecutionInstance
+        """
+        response = await self._version.domain.twilio.request_async("GET", target_url)
+        return ExecutionPage(self._version, response, self._solution)
+
+    def get(self, sid: str) -> ExecutionContext:
+        """
+        Constructs a ExecutionContext
+
+        :param sid: The SID of the Execution resource to update.
+        """
+        return ExecutionContext(
+            self._version, flow_sid=self._solution["flow_sid"], sid=sid
+        )
+
+    def __call__(self, sid: str) -> ExecutionContext:
+        """
+        Constructs a ExecutionContext
+
+        :param sid: The SID of the Execution resource to update.
+        """
+        return ExecutionContext(
+            self._version, flow_sid=self._solution["flow_sid"], sid=sid
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V1.ExecutionList>"

venv/lib/python3.11/site-packages/twilio/rest/studio/v1/flow/execution/execution_context.py

@@ -0,0 +1,214 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Studio
+    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 ExecutionContextInstance(InstanceResource):
+
+    """
+    :ivar account_sid: The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the ExecutionContext resource.
+    :ivar context: The current state of the Flow's Execution. As a flow executes, we save its state in this context. We save data that your widgets can access as variables in configuration fields or in text areas as variable substitution.
+    :ivar flow_sid: The SID of the Flow.
+    :ivar execution_sid: The SID of the context's Execution resource.
+    :ivar url: The absolute URL of the resource.
+    """
+
+    def __init__(
+        self,
+        version: Version,
+        payload: Dict[str, Any],
+        flow_sid: str,
+        execution_sid: str,
+    ):
+        super().__init__(version)
+
+        self.account_sid: Optional[str] = payload.get("account_sid")
+        self.context: Optional[Dict[str, object]] = payload.get("context")
+        self.flow_sid: Optional[str] = payload.get("flow_sid")
+        self.execution_sid: Optional[str] = payload.get("execution_sid")
+        self.url: Optional[str] = payload.get("url")
+
+        self._solution = {
+            "flow_sid": flow_sid,
+            "execution_sid": execution_sid,
+        }
+        self._context: Optional[ExecutionContextContext] = None
+
+    @property
+    def _proxy(self) -> "ExecutionContextContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: ExecutionContextContext for this ExecutionContextInstance
+        """
+        if self._context is None:
+            self._context = ExecutionContextContext(
+                self._version,
+                flow_sid=self._solution["flow_sid"],
+                execution_sid=self._solution["execution_sid"],
+            )
+        return self._context
+
+    def fetch(self) -> "ExecutionContextInstance":
+        """
+        Fetch the ExecutionContextInstance
+
+
+        :returns: The fetched ExecutionContextInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "ExecutionContextInstance":
+        """
+        Asynchronous coroutine to fetch the ExecutionContextInstance
+
+
+        :returns: The fetched ExecutionContextInstance
+        """
+        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.Studio.V1.ExecutionContextInstance {}>".format(context)
+
+
+class ExecutionContextContext(InstanceContext):
+    def __init__(self, version: Version, flow_sid: str, execution_sid: str):
+        """
+        Initialize the ExecutionContextContext
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow with the Execution context to fetch.
+        :param execution_sid: The SID of the Execution context to fetch.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "execution_sid": execution_sid,
+        }
+        self._uri = "/Flows/{flow_sid}/Executions/{execution_sid}/Context".format(
+            **self._solution
+        )
+
+    def fetch(self) -> ExecutionContextInstance:
+        """
+        Fetch the ExecutionContextInstance
+
+
+        :returns: The fetched ExecutionContextInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return ExecutionContextInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+        )
+
+    async def fetch_async(self) -> ExecutionContextInstance:
+        """
+        Asynchronous coroutine to fetch the ExecutionContextInstance
+
+
+        :returns: The fetched ExecutionContextInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return ExecutionContextInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_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.Studio.V1.ExecutionContextContext {}>".format(context)
+
+
+class ExecutionContextList(ListResource):
+    def __init__(self, version: Version, flow_sid: str, execution_sid: str):
+        """
+        Initialize the ExecutionContextList
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow with the Execution context to fetch.
+        :param execution_sid: The SID of the Execution context to fetch.
+
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "execution_sid": execution_sid,
+        }
+
+    def get(self) -> ExecutionContextContext:
+        """
+        Constructs a ExecutionContextContext
+
+        """
+        return ExecutionContextContext(
+            self._version,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+        )
+
+    def __call__(self) -> ExecutionContextContext:
+        """
+        Constructs a ExecutionContextContext
+
+        """
+        return ExecutionContextContext(
+            self._version,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V1.ExecutionContextList>"

venv/lib/python3.11/site-packages/twilio/rest/studio/v1/flow/execution/execution_step/__init__.py

@@ -0,0 +1,481 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Studio
+    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.studio.v1.flow.execution.execution_step.execution_step_context import (
+    ExecutionStepContextList,
+)
+
+
+class ExecutionStepInstance(InstanceResource):
+
+    """
+    :ivar sid: The unique string that we created to identify the ExecutionStep resource.
+    :ivar account_sid: The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the ExecutionStep resource.
+    :ivar flow_sid: The SID of the Flow.
+    :ivar execution_sid: The SID of the Step's Execution resource.
+    :ivar name: The event that caused the Flow to transition to the Step.
+    :ivar context: The current state of the Flow's Execution. As a flow executes, we save its state in this context. We save data that your widgets can access as variables in configuration fields or in text areas as variable substitution.
+    :ivar transitioned_from: The Widget that preceded the Widget for the Step.
+    :ivar transitioned_to: The Widget that will follow the Widget for the Step.
+    :ivar date_created: The date and time in GMT when the resource was created specified in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
+    :ivar date_updated: The date and time in GMT when the resource was last updated specified in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
+    :ivar url: The absolute URL of the resource.
+    :ivar links: The URLs of related resources.
+    """
+
+    def __init__(
+        self,
+        version: Version,
+        payload: Dict[str, Any],
+        flow_sid: str,
+        execution_sid: str,
+        sid: Optional[str] = None,
+    ):
+        super().__init__(version)
+
+        self.sid: Optional[str] = payload.get("sid")
+        self.account_sid: Optional[str] = payload.get("account_sid")
+        self.flow_sid: Optional[str] = payload.get("flow_sid")
+        self.execution_sid: Optional[str] = payload.get("execution_sid")
+        self.name: Optional[str] = payload.get("name")
+        self.context: Optional[Dict[str, object]] = payload.get("context")
+        self.transitioned_from: Optional[str] = payload.get("transitioned_from")
+        self.transitioned_to: Optional[str] = payload.get("transitioned_to")
+        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.links: Optional[Dict[str, object]] = payload.get("links")
+
+        self._solution = {
+            "flow_sid": flow_sid,
+            "execution_sid": execution_sid,
+            "sid": sid or self.sid,
+        }
+        self._context: Optional[ExecutionStepContext] = None
+
+    @property
+    def _proxy(self) -> "ExecutionStepContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: ExecutionStepContext for this ExecutionStepInstance
+        """
+        if self._context is None:
+            self._context = ExecutionStepContext(
+                self._version,
+                flow_sid=self._solution["flow_sid"],
+                execution_sid=self._solution["execution_sid"],
+                sid=self._solution["sid"],
+            )
+        return self._context
+
+    def fetch(self) -> "ExecutionStepInstance":
+        """
+        Fetch the ExecutionStepInstance
+
+
+        :returns: The fetched ExecutionStepInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "ExecutionStepInstance":
+        """
+        Asynchronous coroutine to fetch the ExecutionStepInstance
+
+
+        :returns: The fetched ExecutionStepInstance
+        """
+        return await self._proxy.fetch_async()
+
+    @property
+    def step_context(self) -> ExecutionStepContextList:
+        """
+        Access the step_context
+        """
+        return self._proxy.step_context
+
+    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.Studio.V1.ExecutionStepInstance {}>".format(context)
+
+
+class ExecutionStepContext(InstanceContext):
+    def __init__(self, version: Version, flow_sid: str, execution_sid: str, sid: str):
+        """
+        Initialize the ExecutionStepContext
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow with the Step to fetch.
+        :param execution_sid: The SID of the Execution resource with the Step to fetch.
+        :param sid: The SID of the ExecutionStep resource to fetch.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "execution_sid": execution_sid,
+            "sid": sid,
+        }
+        self._uri = "/Flows/{flow_sid}/Executions/{execution_sid}/Steps/{sid}".format(
+            **self._solution
+        )
+
+        self._step_context: Optional[ExecutionStepContextList] = None
+
+    def fetch(self) -> ExecutionStepInstance:
+        """
+        Fetch the ExecutionStepInstance
+
+
+        :returns: The fetched ExecutionStepInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return ExecutionStepInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+            sid=self._solution["sid"],
+        )
+
+    async def fetch_async(self) -> ExecutionStepInstance:
+        """
+        Asynchronous coroutine to fetch the ExecutionStepInstance
+
+
+        :returns: The fetched ExecutionStepInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return ExecutionStepInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+            sid=self._solution["sid"],
+        )
+
+    @property
+    def step_context(self) -> ExecutionStepContextList:
+        """
+        Access the step_context
+        """
+        if self._step_context is None:
+            self._step_context = ExecutionStepContextList(
+                self._version,
+                self._solution["flow_sid"],
+                self._solution["execution_sid"],
+                self._solution["sid"],
+            )
+        return self._step_context
+
+    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.Studio.V1.ExecutionStepContext {}>".format(context)
+
+
+class ExecutionStepPage(Page):
+    def get_instance(self, payload: Dict[str, Any]) -> ExecutionStepInstance:
+        """
+        Build an instance of ExecutionStepInstance
+
+        :param payload: Payload response from the API
+        """
+        return ExecutionStepInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V1.ExecutionStepPage>"
+
+
+class ExecutionStepList(ListResource):
+    def __init__(self, version: Version, flow_sid: str, execution_sid: str):
+        """
+        Initialize the ExecutionStepList
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow with the Steps to read.
+        :param execution_sid: The SID of the Execution with the Steps to read.
+
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "execution_sid": execution_sid,
+        }
+        self._uri = "/Flows/{flow_sid}/Executions/{execution_sid}/Steps".format(
+            **self._solution
+        )
+
+    def stream(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> Iterator[ExecutionStepInstance]:
+        """
+        Streams ExecutionStepInstance 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[ExecutionStepInstance]:
+        """
+        Asynchronously streams ExecutionStepInstance 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[ExecutionStepInstance]:
+        """
+        Lists ExecutionStepInstance 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[ExecutionStepInstance]:
+        """
+        Asynchronously lists ExecutionStepInstance 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,
+    ) -> ExecutionStepPage:
+        """
+        Retrieve a single page of ExecutionStepInstance 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 ExecutionStepInstance
+        """
+        data = values.of(
+            {
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = self._version.page(method="GET", uri=self._uri, params=data)
+        return ExecutionStepPage(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,
+    ) -> ExecutionStepPage:
+        """
+        Asynchronously retrieve a single page of ExecutionStepInstance 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 ExecutionStepInstance
+        """
+        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 ExecutionStepPage(self._version, response, self._solution)
+
+    def get_page(self, target_url: str) -> ExecutionStepPage:
+        """
+        Retrieve a specific page of ExecutionStepInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of ExecutionStepInstance
+        """
+        response = self._version.domain.twilio.request("GET", target_url)
+        return ExecutionStepPage(self._version, response, self._solution)
+
+    async def get_page_async(self, target_url: str) -> ExecutionStepPage:
+        """
+        Asynchronously retrieve a specific page of ExecutionStepInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of ExecutionStepInstance
+        """
+        response = await self._version.domain.twilio.request_async("GET", target_url)
+        return ExecutionStepPage(self._version, response, self._solution)
+
+    def get(self, sid: str) -> ExecutionStepContext:
+        """
+        Constructs a ExecutionStepContext
+
+        :param sid: The SID of the ExecutionStep resource to fetch.
+        """
+        return ExecutionStepContext(
+            self._version,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+            sid=sid,
+        )
+
+    def __call__(self, sid: str) -> ExecutionStepContext:
+        """
+        Constructs a ExecutionStepContext
+
+        :param sid: The SID of the ExecutionStep resource to fetch.
+        """
+        return ExecutionStepContext(
+            self._version,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+            sid=sid,
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V1.ExecutionStepList>"

venv/lib/python3.11/site-packages/twilio/rest/studio/v1/flow/execution/execution_step/execution_step_context.py

@@ -0,0 +1,231 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Studio
+    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 ExecutionStepContextInstance(InstanceResource):
+
+    """
+    :ivar account_sid: The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the ExecutionStepContext resource.
+    :ivar context: The current state of the Flow's Execution. As a flow executes, we save its state in this context. We save data that your widgets can access as variables in configuration fields or in text areas as variable substitution.
+    :ivar execution_sid: The SID of the context's Execution resource.
+    :ivar flow_sid: The SID of the Flow.
+    :ivar step_sid: The SID of the Step that the context is associated with.
+    :ivar url: The absolute URL of the resource.
+    """
+
+    def __init__(
+        self,
+        version: Version,
+        payload: Dict[str, Any],
+        flow_sid: str,
+        execution_sid: str,
+        step_sid: str,
+    ):
+        super().__init__(version)
+
+        self.account_sid: Optional[str] = payload.get("account_sid")
+        self.context: Optional[Dict[str, object]] = payload.get("context")
+        self.execution_sid: Optional[str] = payload.get("execution_sid")
+        self.flow_sid: Optional[str] = payload.get("flow_sid")
+        self.step_sid: Optional[str] = payload.get("step_sid")
+        self.url: Optional[str] = payload.get("url")
+
+        self._solution = {
+            "flow_sid": flow_sid,
+            "execution_sid": execution_sid,
+            "step_sid": step_sid,
+        }
+        self._context: Optional[ExecutionStepContextContext] = None
+
+    @property
+    def _proxy(self) -> "ExecutionStepContextContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: ExecutionStepContextContext for this ExecutionStepContextInstance
+        """
+        if self._context is None:
+            self._context = ExecutionStepContextContext(
+                self._version,
+                flow_sid=self._solution["flow_sid"],
+                execution_sid=self._solution["execution_sid"],
+                step_sid=self._solution["step_sid"],
+            )
+        return self._context
+
+    def fetch(self) -> "ExecutionStepContextInstance":
+        """
+        Fetch the ExecutionStepContextInstance
+
+
+        :returns: The fetched ExecutionStepContextInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "ExecutionStepContextInstance":
+        """
+        Asynchronous coroutine to fetch the ExecutionStepContextInstance
+
+
+        :returns: The fetched ExecutionStepContextInstance
+        """
+        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.Studio.V1.ExecutionStepContextInstance {}>".format(context)
+
+
+class ExecutionStepContextContext(InstanceContext):
+    def __init__(
+        self, version: Version, flow_sid: str, execution_sid: str, step_sid: str
+    ):
+        """
+        Initialize the ExecutionStepContextContext
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow with the Step to fetch.
+        :param execution_sid: The SID of the Execution resource with the Step to fetch.
+        :param step_sid: The SID of the Step to fetch.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "execution_sid": execution_sid,
+            "step_sid": step_sid,
+        }
+        self._uri = "/Flows/{flow_sid}/Executions/{execution_sid}/Steps/{step_sid}/Context".format(
+            **self._solution
+        )
+
+    def fetch(self) -> ExecutionStepContextInstance:
+        """
+        Fetch the ExecutionStepContextInstance
+
+
+        :returns: The fetched ExecutionStepContextInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return ExecutionStepContextInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+            step_sid=self._solution["step_sid"],
+        )
+
+    async def fetch_async(self) -> ExecutionStepContextInstance:
+        """
+        Asynchronous coroutine to fetch the ExecutionStepContextInstance
+
+
+        :returns: The fetched ExecutionStepContextInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return ExecutionStepContextInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+            step_sid=self._solution["step_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.Studio.V1.ExecutionStepContextContext {}>".format(context)
+
+
+class ExecutionStepContextList(ListResource):
+    def __init__(
+        self, version: Version, flow_sid: str, execution_sid: str, step_sid: str
+    ):
+        """
+        Initialize the ExecutionStepContextList
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow with the Step to fetch.
+        :param execution_sid: The SID of the Execution resource with the Step to fetch.
+        :param step_sid: The SID of the Step to fetch.
+
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "execution_sid": execution_sid,
+            "step_sid": step_sid,
+        }
+
+    def get(self) -> ExecutionStepContextContext:
+        """
+        Constructs a ExecutionStepContextContext
+
+        """
+        return ExecutionStepContextContext(
+            self._version,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+            step_sid=self._solution["step_sid"],
+        )
+
+    def __call__(self) -> ExecutionStepContextContext:
+        """
+        Constructs a ExecutionStepContextContext
+
+        """
+        return ExecutionStepContextContext(
+            self._version,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+            step_sid=self._solution["step_sid"],
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V1.ExecutionStepContextList>"

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

@@ -0,0 +1,50 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Studio
+    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.studio.v2.flow import FlowList
+from twilio.rest.studio.v2.flow_validate import FlowValidateList
+
+
+class V2(Version):
+    def __init__(self, domain: Domain):
+        """
+        Initialize the V2 version of Studio
+
+        :param domain: The Twilio.studio domain
+        """
+        super().__init__(domain, "v2")
+        self._flows: Optional[FlowList] = None
+        self._flow_validate: Optional[FlowValidateList] = None
+
+    @property
+    def flows(self) -> FlowList:
+        if self._flows is None:
+            self._flows = FlowList(self)
+        return self._flows
+
+    @property
+    def flow_validate(self) -> FlowValidateList:
+        if self._flow_validate is None:
+            self._flow_validate = FlowValidateList(self)
+        return self._flow_validate
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V2>"

venv/lib/python3.11/site-packages/twilio/rest/studio/v2/flow/__init__.py

@@ -0,0 +1,711 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Studio
+    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, serialize, 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.studio.v2.flow.execution import ExecutionList
+from twilio.rest.studio.v2.flow.flow_revision import FlowRevisionList
+from twilio.rest.studio.v2.flow.flow_test_user import FlowTestUserList
+
+
+class FlowInstance(InstanceResource):
+    class Status(object):
+        DRAFT = "draft"
+        PUBLISHED = "published"
+
+    """
+    :ivar sid: The unique string that we created to identify the Flow resource.
+    :ivar account_sid: The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the Flow resource.
+    :ivar friendly_name: The string that you assigned to describe the Flow.
+    :ivar definition: JSON representation of flow definition.
+    :ivar status: 
+    :ivar revision: The latest revision number of the Flow's definition.
+    :ivar commit_message: Description of change made in the revision.
+    :ivar valid: Boolean if the flow definition is valid.
+    :ivar errors: List of error in the flow definition.
+    :ivar warnings: List of warnings in the flow definition.
+    :ivar date_created: The date and time in GMT when the resource was created specified in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
+    :ivar date_updated: The date and time in GMT when the resource was last updated specified in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
+    :ivar webhook_url: 
+    :ivar url: The absolute URL of the resource.
+    :ivar links: The URLs of the Flow's nested resources.
+    """
+
+    def __init__(
+        self, version: Version, payload: Dict[str, Any], sid: Optional[str] = None
+    ):
+        super().__init__(version)
+
+        self.sid: Optional[str] = payload.get("sid")
+        self.account_sid: Optional[str] = payload.get("account_sid")
+        self.friendly_name: Optional[str] = payload.get("friendly_name")
+        self.definition: Optional[Dict[str, object]] = payload.get("definition")
+        self.status: Optional["FlowInstance.Status"] = payload.get("status")
+        self.revision: Optional[int] = deserialize.integer(payload.get("revision"))
+        self.commit_message: Optional[str] = payload.get("commit_message")
+        self.valid: Optional[bool] = payload.get("valid")
+        self.errors: Optional[List[object]] = payload.get("errors")
+        self.warnings: Optional[List[object]] = payload.get("warnings")
+        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.webhook_url: Optional[str] = payload.get("webhook_url")
+        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[FlowContext] = None
+
+    @property
+    def _proxy(self) -> "FlowContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: FlowContext for this FlowInstance
+        """
+        if self._context is None:
+            self._context = FlowContext(
+                self._version,
+                sid=self._solution["sid"],
+            )
+        return self._context
+
+    def delete(self) -> bool:
+        """
+        Deletes the FlowInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return self._proxy.delete()
+
+    async def delete_async(self) -> bool:
+        """
+        Asynchronous coroutine that deletes the FlowInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return await self._proxy.delete_async()
+
+    def fetch(self) -> "FlowInstance":
+        """
+        Fetch the FlowInstance
+
+
+        :returns: The fetched FlowInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "FlowInstance":
+        """
+        Asynchronous coroutine to fetch the FlowInstance
+
+
+        :returns: The fetched FlowInstance
+        """
+        return await self._proxy.fetch_async()
+
+    def update(
+        self,
+        status: "FlowInstance.Status",
+        friendly_name: Union[str, object] = values.unset,
+        definition: Union[object, object] = values.unset,
+        commit_message: Union[str, object] = values.unset,
+    ) -> "FlowInstance":
+        """
+        Update the FlowInstance
+
+        :param status:
+        :param friendly_name: The string that you assigned to describe the Flow.
+        :param definition: JSON representation of flow definition.
+        :param commit_message: Description of change made in the revision.
+
+        :returns: The updated FlowInstance
+        """
+        return self._proxy.update(
+            status=status,
+            friendly_name=friendly_name,
+            definition=definition,
+            commit_message=commit_message,
+        )
+
+    async def update_async(
+        self,
+        status: "FlowInstance.Status",
+        friendly_name: Union[str, object] = values.unset,
+        definition: Union[object, object] = values.unset,
+        commit_message: Union[str, object] = values.unset,
+    ) -> "FlowInstance":
+        """
+        Asynchronous coroutine to update the FlowInstance
+
+        :param status:
+        :param friendly_name: The string that you assigned to describe the Flow.
+        :param definition: JSON representation of flow definition.
+        :param commit_message: Description of change made in the revision.
+
+        :returns: The updated FlowInstance
+        """
+        return await self._proxy.update_async(
+            status=status,
+            friendly_name=friendly_name,
+            definition=definition,
+            commit_message=commit_message,
+        )
+
+    @property
+    def executions(self) -> ExecutionList:
+        """
+        Access the executions
+        """
+        return self._proxy.executions
+
+    @property
+    def revisions(self) -> FlowRevisionList:
+        """
+        Access the revisions
+        """
+        return self._proxy.revisions
+
+    @property
+    def test_users(self) -> FlowTestUserList:
+        """
+        Access the test_users
+        """
+        return self._proxy.test_users
+
+    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.Studio.V2.FlowInstance {}>".format(context)
+
+
+class FlowContext(InstanceContext):
+    def __init__(self, version: Version, sid: str):
+        """
+        Initialize the FlowContext
+
+        :param version: Version that contains the resource
+        :param sid: The SID of the Flow resource to fetch.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "sid": sid,
+        }
+        self._uri = "/Flows/{sid}".format(**self._solution)
+
+        self._executions: Optional[ExecutionList] = None
+        self._revisions: Optional[FlowRevisionList] = None
+        self._test_users: Optional[FlowTestUserList] = None
+
+    def delete(self) -> bool:
+        """
+        Deletes the FlowInstance
+
+
+        :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 FlowInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return await self._version.delete_async(
+            method="DELETE",
+            uri=self._uri,
+        )
+
+    def fetch(self) -> FlowInstance:
+        """
+        Fetch the FlowInstance
+
+
+        :returns: The fetched FlowInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return FlowInstance(
+            self._version,
+            payload,
+            sid=self._solution["sid"],
+        )
+
+    async def fetch_async(self) -> FlowInstance:
+        """
+        Asynchronous coroutine to fetch the FlowInstance
+
+
+        :returns: The fetched FlowInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return FlowInstance(
+            self._version,
+            payload,
+            sid=self._solution["sid"],
+        )
+
+    def update(
+        self,
+        status: "FlowInstance.Status",
+        friendly_name: Union[str, object] = values.unset,
+        definition: Union[object, object] = values.unset,
+        commit_message: Union[str, object] = values.unset,
+    ) -> FlowInstance:
+        """
+        Update the FlowInstance
+
+        :param status:
+        :param friendly_name: The string that you assigned to describe the Flow.
+        :param definition: JSON representation of flow definition.
+        :param commit_message: Description of change made in the revision.
+
+        :returns: The updated FlowInstance
+        """
+        data = values.of(
+            {
+                "Status": status,
+                "FriendlyName": friendly_name,
+                "Definition": serialize.object(definition),
+                "CommitMessage": commit_message,
+            }
+        )
+
+        payload = self._version.update(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return FlowInstance(self._version, payload, sid=self._solution["sid"])
+
+    async def update_async(
+        self,
+        status: "FlowInstance.Status",
+        friendly_name: Union[str, object] = values.unset,
+        definition: Union[object, object] = values.unset,
+        commit_message: Union[str, object] = values.unset,
+    ) -> FlowInstance:
+        """
+        Asynchronous coroutine to update the FlowInstance
+
+        :param status:
+        :param friendly_name: The string that you assigned to describe the Flow.
+        :param definition: JSON representation of flow definition.
+        :param commit_message: Description of change made in the revision.
+
+        :returns: The updated FlowInstance
+        """
+        data = values.of(
+            {
+                "Status": status,
+                "FriendlyName": friendly_name,
+                "Definition": serialize.object(definition),
+                "CommitMessage": commit_message,
+            }
+        )
+
+        payload = await self._version.update_async(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return FlowInstance(self._version, payload, sid=self._solution["sid"])
+
+    @property
+    def executions(self) -> ExecutionList:
+        """
+        Access the executions
+        """
+        if self._executions is None:
+            self._executions = ExecutionList(
+                self._version,
+                self._solution["sid"],
+            )
+        return self._executions
+
+    @property
+    def revisions(self) -> FlowRevisionList:
+        """
+        Access the revisions
+        """
+        if self._revisions is None:
+            self._revisions = FlowRevisionList(
+                self._version,
+                self._solution["sid"],
+            )
+        return self._revisions
+
+    @property
+    def test_users(self) -> FlowTestUserList:
+        """
+        Access the test_users
+        """
+        if self._test_users is None:
+            self._test_users = FlowTestUserList(
+                self._version,
+                self._solution["sid"],
+            )
+        return self._test_users
+
+    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.Studio.V2.FlowContext {}>".format(context)
+
+
+class FlowPage(Page):
+    def get_instance(self, payload: Dict[str, Any]) -> FlowInstance:
+        """
+        Build an instance of FlowInstance
+
+        :param payload: Payload response from the API
+        """
+        return FlowInstance(self._version, payload)
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V2.FlowPage>"
+
+
+class FlowList(ListResource):
+    def __init__(self, version: Version):
+        """
+        Initialize the FlowList
+
+        :param version: Version that contains the resource
+
+        """
+        super().__init__(version)
+
+        self._uri = "/Flows"
+
+    def create(
+        self,
+        friendly_name: str,
+        status: "FlowInstance.Status",
+        definition: object,
+        commit_message: Union[str, object] = values.unset,
+    ) -> FlowInstance:
+        """
+        Create the FlowInstance
+
+        :param friendly_name: The string that you assigned to describe the Flow.
+        :param status:
+        :param definition: JSON representation of flow definition.
+        :param commit_message: Description of change made in the revision.
+
+        :returns: The created FlowInstance
+        """
+        data = values.of(
+            {
+                "FriendlyName": friendly_name,
+                "Status": status,
+                "Definition": serialize.object(definition),
+                "CommitMessage": commit_message,
+            }
+        )
+
+        payload = self._version.create(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return FlowInstance(self._version, payload)
+
+    async def create_async(
+        self,
+        friendly_name: str,
+        status: "FlowInstance.Status",
+        definition: object,
+        commit_message: Union[str, object] = values.unset,
+    ) -> FlowInstance:
+        """
+        Asynchronously create the FlowInstance
+
+        :param friendly_name: The string that you assigned to describe the Flow.
+        :param status:
+        :param definition: JSON representation of flow definition.
+        :param commit_message: Description of change made in the revision.
+
+        :returns: The created FlowInstance
+        """
+        data = values.of(
+            {
+                "FriendlyName": friendly_name,
+                "Status": status,
+                "Definition": serialize.object(definition),
+                "CommitMessage": commit_message,
+            }
+        )
+
+        payload = await self._version.create_async(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return FlowInstance(self._version, payload)
+
+    def stream(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> Iterator[FlowInstance]:
+        """
+        Streams FlowInstance 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[FlowInstance]:
+        """
+        Asynchronously streams FlowInstance 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[FlowInstance]:
+        """
+        Lists FlowInstance 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[FlowInstance]:
+        """
+        Asynchronously lists FlowInstance 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,
+    ) -> FlowPage:
+        """
+        Retrieve a single page of FlowInstance 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 FlowInstance
+        """
+        data = values.of(
+            {
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = self._version.page(method="GET", uri=self._uri, params=data)
+        return FlowPage(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,
+    ) -> FlowPage:
+        """
+        Asynchronously retrieve a single page of FlowInstance 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 FlowInstance
+        """
+        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 FlowPage(self._version, response)
+
+    def get_page(self, target_url: str) -> FlowPage:
+        """
+        Retrieve a specific page of FlowInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of FlowInstance
+        """
+        response = self._version.domain.twilio.request("GET", target_url)
+        return FlowPage(self._version, response)
+
+    async def get_page_async(self, target_url: str) -> FlowPage:
+        """
+        Asynchronously retrieve a specific page of FlowInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of FlowInstance
+        """
+        response = await self._version.domain.twilio.request_async("GET", target_url)
+        return FlowPage(self._version, response)
+
+    def get(self, sid: str) -> FlowContext:
+        """
+        Constructs a FlowContext
+
+        :param sid: The SID of the Flow resource to fetch.
+        """
+        return FlowContext(self._version, sid=sid)
+
+    def __call__(self, sid: str) -> FlowContext:
+        """
+        Constructs a FlowContext
+
+        :param sid: The SID of the Flow resource to fetch.
+        """
+        return FlowContext(self._version, sid=sid)
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V2.FlowList>"

venv/lib/python3.11/site-packages/twilio/rest/studio/v2/flow/execution/__init__.py

@@ -0,0 +1,703 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Studio
+    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, serialize, 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.studio.v2.flow.execution.execution_context import ExecutionContextList
+from twilio.rest.studio.v2.flow.execution.execution_step import ExecutionStepList
+
+
+class ExecutionInstance(InstanceResource):
+    class Status(object):
+        ACTIVE = "active"
+        ENDED = "ended"
+
+    """
+    :ivar sid: The unique string that we created to identify the Execution resource.
+    :ivar account_sid: The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the Execution resource.
+    :ivar flow_sid: The SID of the Flow.
+    :ivar contact_channel_address: The phone number, SIP address or Client identifier that triggered the Execution. Phone numbers are in E.164 format (e.g. +16175551212). SIP addresses are formatted as `name@company.com`. Client identifiers are formatted `client:name`.
+    :ivar context: The current state of the Flow's Execution. As a flow executes, we save its state in this context. We save data that your widgets can access as variables in configuration fields or in text areas as variable substitution.
+    :ivar status: 
+    :ivar date_created: The date and time in GMT when the resource was created specified in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
+    :ivar date_updated: The date and time in GMT when the resource was last updated specified in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
+    :ivar url: The absolute URL of the resource.
+    :ivar links: The URLs of nested resources.
+    """
+
+    def __init__(
+        self,
+        version: Version,
+        payload: Dict[str, Any],
+        flow_sid: str,
+        sid: Optional[str] = None,
+    ):
+        super().__init__(version)
+
+        self.sid: Optional[str] = payload.get("sid")
+        self.account_sid: Optional[str] = payload.get("account_sid")
+        self.flow_sid: Optional[str] = payload.get("flow_sid")
+        self.contact_channel_address: Optional[str] = payload.get(
+            "contact_channel_address"
+        )
+        self.context: Optional[Dict[str, object]] = payload.get("context")
+        self.status: Optional["ExecutionInstance.Status"] = payload.get("status")
+        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.links: Optional[Dict[str, object]] = payload.get("links")
+
+        self._solution = {
+            "flow_sid": flow_sid,
+            "sid": sid or self.sid,
+        }
+        self._context: Optional[ExecutionContext] = None
+
+    @property
+    def _proxy(self) -> "ExecutionContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: ExecutionContext for this ExecutionInstance
+        """
+        if self._context is None:
+            self._context = ExecutionContext(
+                self._version,
+                flow_sid=self._solution["flow_sid"],
+                sid=self._solution["sid"],
+            )
+        return self._context
+
+    def delete(self) -> bool:
+        """
+        Deletes the ExecutionInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return self._proxy.delete()
+
+    async def delete_async(self) -> bool:
+        """
+        Asynchronous coroutine that deletes the ExecutionInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return await self._proxy.delete_async()
+
+    def fetch(self) -> "ExecutionInstance":
+        """
+        Fetch the ExecutionInstance
+
+
+        :returns: The fetched ExecutionInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "ExecutionInstance":
+        """
+        Asynchronous coroutine to fetch the ExecutionInstance
+
+
+        :returns: The fetched ExecutionInstance
+        """
+        return await self._proxy.fetch_async()
+
+    def update(self, status: "ExecutionInstance.Status") -> "ExecutionInstance":
+        """
+        Update the ExecutionInstance
+
+        :param status:
+
+        :returns: The updated ExecutionInstance
+        """
+        return self._proxy.update(
+            status=status,
+        )
+
+    async def update_async(
+        self, status: "ExecutionInstance.Status"
+    ) -> "ExecutionInstance":
+        """
+        Asynchronous coroutine to update the ExecutionInstance
+
+        :param status:
+
+        :returns: The updated ExecutionInstance
+        """
+        return await self._proxy.update_async(
+            status=status,
+        )
+
+    @property
+    def execution_context(self) -> ExecutionContextList:
+        """
+        Access the execution_context
+        """
+        return self._proxy.execution_context
+
+    @property
+    def steps(self) -> ExecutionStepList:
+        """
+        Access the steps
+        """
+        return self._proxy.steps
+
+    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.Studio.V2.ExecutionInstance {}>".format(context)
+
+
+class ExecutionContext(InstanceContext):
+    def __init__(self, version: Version, flow_sid: str, sid: str):
+        """
+        Initialize the ExecutionContext
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow with the Execution resources to update.
+        :param sid: The SID of the Execution resource to update.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "sid": sid,
+        }
+        self._uri = "/Flows/{flow_sid}/Executions/{sid}".format(**self._solution)
+
+        self._execution_context: Optional[ExecutionContextList] = None
+        self._steps: Optional[ExecutionStepList] = None
+
+    def delete(self) -> bool:
+        """
+        Deletes the ExecutionInstance
+
+
+        :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 ExecutionInstance
+
+
+        :returns: True if delete succeeds, False otherwise
+        """
+        return await self._version.delete_async(
+            method="DELETE",
+            uri=self._uri,
+        )
+
+    def fetch(self) -> ExecutionInstance:
+        """
+        Fetch the ExecutionInstance
+
+
+        :returns: The fetched ExecutionInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return ExecutionInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            sid=self._solution["sid"],
+        )
+
+    async def fetch_async(self) -> ExecutionInstance:
+        """
+        Asynchronous coroutine to fetch the ExecutionInstance
+
+
+        :returns: The fetched ExecutionInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return ExecutionInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            sid=self._solution["sid"],
+        )
+
+    def update(self, status: "ExecutionInstance.Status") -> ExecutionInstance:
+        """
+        Update the ExecutionInstance
+
+        :param status:
+
+        :returns: The updated ExecutionInstance
+        """
+        data = values.of(
+            {
+                "Status": status,
+            }
+        )
+
+        payload = self._version.update(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return ExecutionInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            sid=self._solution["sid"],
+        )
+
+    async def update_async(
+        self, status: "ExecutionInstance.Status"
+    ) -> ExecutionInstance:
+        """
+        Asynchronous coroutine to update the ExecutionInstance
+
+        :param status:
+
+        :returns: The updated ExecutionInstance
+        """
+        data = values.of(
+            {
+                "Status": status,
+            }
+        )
+
+        payload = await self._version.update_async(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return ExecutionInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            sid=self._solution["sid"],
+        )
+
+    @property
+    def execution_context(self) -> ExecutionContextList:
+        """
+        Access the execution_context
+        """
+        if self._execution_context is None:
+            self._execution_context = ExecutionContextList(
+                self._version,
+                self._solution["flow_sid"],
+                self._solution["sid"],
+            )
+        return self._execution_context
+
+    @property
+    def steps(self) -> ExecutionStepList:
+        """
+        Access the steps
+        """
+        if self._steps is None:
+            self._steps = ExecutionStepList(
+                self._version,
+                self._solution["flow_sid"],
+                self._solution["sid"],
+            )
+        return self._steps
+
+    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.Studio.V2.ExecutionContext {}>".format(context)
+
+
+class ExecutionPage(Page):
+    def get_instance(self, payload: Dict[str, Any]) -> ExecutionInstance:
+        """
+        Build an instance of ExecutionInstance
+
+        :param payload: Payload response from the API
+        """
+        return ExecutionInstance(
+            self._version, payload, flow_sid=self._solution["flow_sid"]
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V2.ExecutionPage>"
+
+
+class ExecutionList(ListResource):
+    def __init__(self, version: Version, flow_sid: str):
+        """
+        Initialize the ExecutionList
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow with the Execution resources to read.
+
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+        }
+        self._uri = "/Flows/{flow_sid}/Executions".format(**self._solution)
+
+    def create(
+        self, to: str, from_: str, parameters: Union[object, object] = values.unset
+    ) -> ExecutionInstance:
+        """
+        Create the ExecutionInstance
+
+        :param to: The Contact phone number to start a Studio Flow Execution, available as variable `{{contact.channel.address}}`.
+        :param from_: The Twilio phone number to send messages or initiate calls from during the Flow's Execution. Available as variable `{{flow.channel.address}}`. For SMS, this can also be a Messaging Service SID.
+        :param parameters: JSON data that will be added to the Flow's context and that can be accessed as variables inside your Flow. For example, if you pass in `Parameters={\\\"name\\\":\\\"Zeke\\\"}`, a widget in your Flow can reference the variable `{{flow.data.name}}`, which returns \\\"Zeke\\\". Note: the JSON value must explicitly be passed as a string, not as a hash object. Depending on your particular HTTP library, you may need to add quotes or URL encode the JSON string.
+
+        :returns: The created ExecutionInstance
+        """
+        data = values.of(
+            {
+                "To": to,
+                "From": from_,
+                "Parameters": serialize.object(parameters),
+            }
+        )
+
+        payload = self._version.create(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return ExecutionInstance(
+            self._version, payload, flow_sid=self._solution["flow_sid"]
+        )
+
+    async def create_async(
+        self, to: str, from_: str, parameters: Union[object, object] = values.unset
+    ) -> ExecutionInstance:
+        """
+        Asynchronously create the ExecutionInstance
+
+        :param to: The Contact phone number to start a Studio Flow Execution, available as variable `{{contact.channel.address}}`.
+        :param from_: The Twilio phone number to send messages or initiate calls from during the Flow's Execution. Available as variable `{{flow.channel.address}}`. For SMS, this can also be a Messaging Service SID.
+        :param parameters: JSON data that will be added to the Flow's context and that can be accessed as variables inside your Flow. For example, if you pass in `Parameters={\\\"name\\\":\\\"Zeke\\\"}`, a widget in your Flow can reference the variable `{{flow.data.name}}`, which returns \\\"Zeke\\\". Note: the JSON value must explicitly be passed as a string, not as a hash object. Depending on your particular HTTP library, you may need to add quotes or URL encode the JSON string.
+
+        :returns: The created ExecutionInstance
+        """
+        data = values.of(
+            {
+                "To": to,
+                "From": from_,
+                "Parameters": serialize.object(parameters),
+            }
+        )
+
+        payload = await self._version.create_async(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return ExecutionInstance(
+            self._version, payload, flow_sid=self._solution["flow_sid"]
+        )
+
+    def stream(
+        self,
+        date_created_from: Union[datetime, object] = values.unset,
+        date_created_to: Union[datetime, object] = values.unset,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> Iterator[ExecutionInstance]:
+        """
+        Streams ExecutionInstance 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 datetime date_created_from: Only show Execution resources starting on or after this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :param datetime date_created_to: Only show Execution resources starting before this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :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(
+            date_created_from=date_created_from,
+            date_created_to=date_created_to,
+            page_size=limits["page_size"],
+        )
+
+        return self._version.stream(page, limits["limit"])
+
+    async def stream_async(
+        self,
+        date_created_from: Union[datetime, object] = values.unset,
+        date_created_to: Union[datetime, object] = values.unset,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> AsyncIterator[ExecutionInstance]:
+        """
+        Asynchronously streams ExecutionInstance 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 datetime date_created_from: Only show Execution resources starting on or after this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :param datetime date_created_to: Only show Execution resources starting before this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :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(
+            date_created_from=date_created_from,
+            date_created_to=date_created_to,
+            page_size=limits["page_size"],
+        )
+
+        return self._version.stream_async(page, limits["limit"])
+
+    def list(
+        self,
+        date_created_from: Union[datetime, object] = values.unset,
+        date_created_to: Union[datetime, object] = values.unset,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> List[ExecutionInstance]:
+        """
+        Lists ExecutionInstance records from the API as a list.
+        Unlike stream(), this operation is eager and will load `limit` records into
+        memory before returning.
+
+        :param datetime date_created_from: Only show Execution resources starting on or after this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :param datetime date_created_to: Only show Execution resources starting before this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :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(
+                date_created_from=date_created_from,
+                date_created_to=date_created_to,
+                limit=limit,
+                page_size=page_size,
+            )
+        )
+
+    async def list_async(
+        self,
+        date_created_from: Union[datetime, object] = values.unset,
+        date_created_to: Union[datetime, object] = values.unset,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> List[ExecutionInstance]:
+        """
+        Asynchronously lists ExecutionInstance records from the API as a list.
+        Unlike stream(), this operation is eager and will load `limit` records into
+        memory before returning.
+
+        :param datetime date_created_from: Only show Execution resources starting on or after this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :param datetime date_created_to: Only show Execution resources starting before this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :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(
+                date_created_from=date_created_from,
+                date_created_to=date_created_to,
+                limit=limit,
+                page_size=page_size,
+            )
+        ]
+
+    def page(
+        self,
+        date_created_from: Union[datetime, object] = values.unset,
+        date_created_to: Union[datetime, object] = values.unset,
+        page_token: Union[str, object] = values.unset,
+        page_number: Union[int, object] = values.unset,
+        page_size: Union[int, object] = values.unset,
+    ) -> ExecutionPage:
+        """
+        Retrieve a single page of ExecutionInstance records from the API.
+        Request is executed immediately
+
+        :param date_created_from: Only show Execution resources starting on or after this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :param date_created_to: Only show Execution resources starting before this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :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 ExecutionInstance
+        """
+        data = values.of(
+            {
+                "DateCreatedFrom": serialize.iso8601_datetime(date_created_from),
+                "DateCreatedTo": serialize.iso8601_datetime(date_created_to),
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = self._version.page(method="GET", uri=self._uri, params=data)
+        return ExecutionPage(self._version, response, self._solution)
+
+    async def page_async(
+        self,
+        date_created_from: Union[datetime, object] = values.unset,
+        date_created_to: Union[datetime, object] = values.unset,
+        page_token: Union[str, object] = values.unset,
+        page_number: Union[int, object] = values.unset,
+        page_size: Union[int, object] = values.unset,
+    ) -> ExecutionPage:
+        """
+        Asynchronously retrieve a single page of ExecutionInstance records from the API.
+        Request is executed immediately
+
+        :param date_created_from: Only show Execution resources starting on or after this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :param date_created_to: Only show Execution resources starting before this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+        :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 ExecutionInstance
+        """
+        data = values.of(
+            {
+                "DateCreatedFrom": serialize.iso8601_datetime(date_created_from),
+                "DateCreatedTo": serialize.iso8601_datetime(date_created_to),
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = await self._version.page_async(
+            method="GET", uri=self._uri, params=data
+        )
+        return ExecutionPage(self._version, response, self._solution)
+
+    def get_page(self, target_url: str) -> ExecutionPage:
+        """
+        Retrieve a specific page of ExecutionInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of ExecutionInstance
+        """
+        response = self._version.domain.twilio.request("GET", target_url)
+        return ExecutionPage(self._version, response, self._solution)
+
+    async def get_page_async(self, target_url: str) -> ExecutionPage:
+        """
+        Asynchronously retrieve a specific page of ExecutionInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of ExecutionInstance
+        """
+        response = await self._version.domain.twilio.request_async("GET", target_url)
+        return ExecutionPage(self._version, response, self._solution)
+
+    def get(self, sid: str) -> ExecutionContext:
+        """
+        Constructs a ExecutionContext
+
+        :param sid: The SID of the Execution resource to update.
+        """
+        return ExecutionContext(
+            self._version, flow_sid=self._solution["flow_sid"], sid=sid
+        )
+
+    def __call__(self, sid: str) -> ExecutionContext:
+        """
+        Constructs a ExecutionContext
+
+        :param sid: The SID of the Execution resource to update.
+        """
+        return ExecutionContext(
+            self._version, flow_sid=self._solution["flow_sid"], sid=sid
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V2.ExecutionList>"

venv/lib/python3.11/site-packages/twilio/rest/studio/v2/flow/execution/execution_context.py

@@ -0,0 +1,214 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Studio
+    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 ExecutionContextInstance(InstanceResource):
+
+    """
+    :ivar account_sid: The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the ExecutionContext resource.
+    :ivar context: The current state of the Flow's Execution. As a flow executes, we save its state in this context. We save data that your widgets can access as variables in configuration fields or in text areas as variable substitution.
+    :ivar flow_sid: The SID of the Flow.
+    :ivar execution_sid: The SID of the context's Execution resource.
+    :ivar url: The absolute URL of the resource.
+    """
+
+    def __init__(
+        self,
+        version: Version,
+        payload: Dict[str, Any],
+        flow_sid: str,
+        execution_sid: str,
+    ):
+        super().__init__(version)
+
+        self.account_sid: Optional[str] = payload.get("account_sid")
+        self.context: Optional[Dict[str, object]] = payload.get("context")
+        self.flow_sid: Optional[str] = payload.get("flow_sid")
+        self.execution_sid: Optional[str] = payload.get("execution_sid")
+        self.url: Optional[str] = payload.get("url")
+
+        self._solution = {
+            "flow_sid": flow_sid,
+            "execution_sid": execution_sid,
+        }
+        self._context: Optional[ExecutionContextContext] = None
+
+    @property
+    def _proxy(self) -> "ExecutionContextContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: ExecutionContextContext for this ExecutionContextInstance
+        """
+        if self._context is None:
+            self._context = ExecutionContextContext(
+                self._version,
+                flow_sid=self._solution["flow_sid"],
+                execution_sid=self._solution["execution_sid"],
+            )
+        return self._context
+
+    def fetch(self) -> "ExecutionContextInstance":
+        """
+        Fetch the ExecutionContextInstance
+
+
+        :returns: The fetched ExecutionContextInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "ExecutionContextInstance":
+        """
+        Asynchronous coroutine to fetch the ExecutionContextInstance
+
+
+        :returns: The fetched ExecutionContextInstance
+        """
+        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.Studio.V2.ExecutionContextInstance {}>".format(context)
+
+
+class ExecutionContextContext(InstanceContext):
+    def __init__(self, version: Version, flow_sid: str, execution_sid: str):
+        """
+        Initialize the ExecutionContextContext
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow with the Execution context to fetch.
+        :param execution_sid: The SID of the Execution context to fetch.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "execution_sid": execution_sid,
+        }
+        self._uri = "/Flows/{flow_sid}/Executions/{execution_sid}/Context".format(
+            **self._solution
+        )
+
+    def fetch(self) -> ExecutionContextInstance:
+        """
+        Fetch the ExecutionContextInstance
+
+
+        :returns: The fetched ExecutionContextInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return ExecutionContextInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+        )
+
+    async def fetch_async(self) -> ExecutionContextInstance:
+        """
+        Asynchronous coroutine to fetch the ExecutionContextInstance
+
+
+        :returns: The fetched ExecutionContextInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return ExecutionContextInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_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.Studio.V2.ExecutionContextContext {}>".format(context)
+
+
+class ExecutionContextList(ListResource):
+    def __init__(self, version: Version, flow_sid: str, execution_sid: str):
+        """
+        Initialize the ExecutionContextList
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow with the Execution context to fetch.
+        :param execution_sid: The SID of the Execution context to fetch.
+
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "execution_sid": execution_sid,
+        }
+
+    def get(self) -> ExecutionContextContext:
+        """
+        Constructs a ExecutionContextContext
+
+        """
+        return ExecutionContextContext(
+            self._version,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+        )
+
+    def __call__(self) -> ExecutionContextContext:
+        """
+        Constructs a ExecutionContextContext
+
+        """
+        return ExecutionContextContext(
+            self._version,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V2.ExecutionContextList>"

venv/lib/python3.11/site-packages/twilio/rest/studio/v2/flow/execution/execution_step/__init__.py

@@ -0,0 +1,481 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Studio
+    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.studio.v2.flow.execution.execution_step.execution_step_context import (
+    ExecutionStepContextList,
+)
+
+
+class ExecutionStepInstance(InstanceResource):
+
+    """
+    :ivar sid: The unique string that we created to identify the ExecutionStep resource.
+    :ivar account_sid: The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the ExecutionStep resource.
+    :ivar flow_sid: The SID of the Flow.
+    :ivar execution_sid: The SID of the Step's Execution resource.
+    :ivar name: The event that caused the Flow to transition to the Step.
+    :ivar context: The current state of the Flow's Execution. As a flow executes, we save its state in this context. We save data that your widgets can access as variables in configuration fields or in text areas as variable substitution.
+    :ivar transitioned_from: The Widget that preceded the Widget for the Step.
+    :ivar transitioned_to: The Widget that will follow the Widget for the Step.
+    :ivar date_created: The date and time in GMT when the resource was created specified in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
+    :ivar date_updated: The date and time in GMT when the resource was last updated specified in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
+    :ivar url: The absolute URL of the resource.
+    :ivar links: The URLs of related resources.
+    """
+
+    def __init__(
+        self,
+        version: Version,
+        payload: Dict[str, Any],
+        flow_sid: str,
+        execution_sid: str,
+        sid: Optional[str] = None,
+    ):
+        super().__init__(version)
+
+        self.sid: Optional[str] = payload.get("sid")
+        self.account_sid: Optional[str] = payload.get("account_sid")
+        self.flow_sid: Optional[str] = payload.get("flow_sid")
+        self.execution_sid: Optional[str] = payload.get("execution_sid")
+        self.name: Optional[str] = payload.get("name")
+        self.context: Optional[Dict[str, object]] = payload.get("context")
+        self.transitioned_from: Optional[str] = payload.get("transitioned_from")
+        self.transitioned_to: Optional[str] = payload.get("transitioned_to")
+        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.links: Optional[Dict[str, object]] = payload.get("links")
+
+        self._solution = {
+            "flow_sid": flow_sid,
+            "execution_sid": execution_sid,
+            "sid": sid or self.sid,
+        }
+        self._context: Optional[ExecutionStepContext] = None
+
+    @property
+    def _proxy(self) -> "ExecutionStepContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: ExecutionStepContext for this ExecutionStepInstance
+        """
+        if self._context is None:
+            self._context = ExecutionStepContext(
+                self._version,
+                flow_sid=self._solution["flow_sid"],
+                execution_sid=self._solution["execution_sid"],
+                sid=self._solution["sid"],
+            )
+        return self._context
+
+    def fetch(self) -> "ExecutionStepInstance":
+        """
+        Fetch the ExecutionStepInstance
+
+
+        :returns: The fetched ExecutionStepInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "ExecutionStepInstance":
+        """
+        Asynchronous coroutine to fetch the ExecutionStepInstance
+
+
+        :returns: The fetched ExecutionStepInstance
+        """
+        return await self._proxy.fetch_async()
+
+    @property
+    def step_context(self) -> ExecutionStepContextList:
+        """
+        Access the step_context
+        """
+        return self._proxy.step_context
+
+    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.Studio.V2.ExecutionStepInstance {}>".format(context)
+
+
+class ExecutionStepContext(InstanceContext):
+    def __init__(self, version: Version, flow_sid: str, execution_sid: str, sid: str):
+        """
+        Initialize the ExecutionStepContext
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow with the Step to fetch.
+        :param execution_sid: The SID of the Execution resource with the Step to fetch.
+        :param sid: The SID of the ExecutionStep resource to fetch.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "execution_sid": execution_sid,
+            "sid": sid,
+        }
+        self._uri = "/Flows/{flow_sid}/Executions/{execution_sid}/Steps/{sid}".format(
+            **self._solution
+        )
+
+        self._step_context: Optional[ExecutionStepContextList] = None
+
+    def fetch(self) -> ExecutionStepInstance:
+        """
+        Fetch the ExecutionStepInstance
+
+
+        :returns: The fetched ExecutionStepInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return ExecutionStepInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+            sid=self._solution["sid"],
+        )
+
+    async def fetch_async(self) -> ExecutionStepInstance:
+        """
+        Asynchronous coroutine to fetch the ExecutionStepInstance
+
+
+        :returns: The fetched ExecutionStepInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return ExecutionStepInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+            sid=self._solution["sid"],
+        )
+
+    @property
+    def step_context(self) -> ExecutionStepContextList:
+        """
+        Access the step_context
+        """
+        if self._step_context is None:
+            self._step_context = ExecutionStepContextList(
+                self._version,
+                self._solution["flow_sid"],
+                self._solution["execution_sid"],
+                self._solution["sid"],
+            )
+        return self._step_context
+
+    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.Studio.V2.ExecutionStepContext {}>".format(context)
+
+
+class ExecutionStepPage(Page):
+    def get_instance(self, payload: Dict[str, Any]) -> ExecutionStepInstance:
+        """
+        Build an instance of ExecutionStepInstance
+
+        :param payload: Payload response from the API
+        """
+        return ExecutionStepInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V2.ExecutionStepPage>"
+
+
+class ExecutionStepList(ListResource):
+    def __init__(self, version: Version, flow_sid: str, execution_sid: str):
+        """
+        Initialize the ExecutionStepList
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow with the Steps to read.
+        :param execution_sid: The SID of the Execution with the Steps to read.
+
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "execution_sid": execution_sid,
+        }
+        self._uri = "/Flows/{flow_sid}/Executions/{execution_sid}/Steps".format(
+            **self._solution
+        )
+
+    def stream(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> Iterator[ExecutionStepInstance]:
+        """
+        Streams ExecutionStepInstance 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[ExecutionStepInstance]:
+        """
+        Asynchronously streams ExecutionStepInstance 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[ExecutionStepInstance]:
+        """
+        Lists ExecutionStepInstance 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[ExecutionStepInstance]:
+        """
+        Asynchronously lists ExecutionStepInstance 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,
+    ) -> ExecutionStepPage:
+        """
+        Retrieve a single page of ExecutionStepInstance 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 ExecutionStepInstance
+        """
+        data = values.of(
+            {
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = self._version.page(method="GET", uri=self._uri, params=data)
+        return ExecutionStepPage(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,
+    ) -> ExecutionStepPage:
+        """
+        Asynchronously retrieve a single page of ExecutionStepInstance 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 ExecutionStepInstance
+        """
+        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 ExecutionStepPage(self._version, response, self._solution)
+
+    def get_page(self, target_url: str) -> ExecutionStepPage:
+        """
+        Retrieve a specific page of ExecutionStepInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of ExecutionStepInstance
+        """
+        response = self._version.domain.twilio.request("GET", target_url)
+        return ExecutionStepPage(self._version, response, self._solution)
+
+    async def get_page_async(self, target_url: str) -> ExecutionStepPage:
+        """
+        Asynchronously retrieve a specific page of ExecutionStepInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of ExecutionStepInstance
+        """
+        response = await self._version.domain.twilio.request_async("GET", target_url)
+        return ExecutionStepPage(self._version, response, self._solution)
+
+    def get(self, sid: str) -> ExecutionStepContext:
+        """
+        Constructs a ExecutionStepContext
+
+        :param sid: The SID of the ExecutionStep resource to fetch.
+        """
+        return ExecutionStepContext(
+            self._version,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+            sid=sid,
+        )
+
+    def __call__(self, sid: str) -> ExecutionStepContext:
+        """
+        Constructs a ExecutionStepContext
+
+        :param sid: The SID of the ExecutionStep resource to fetch.
+        """
+        return ExecutionStepContext(
+            self._version,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+            sid=sid,
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V2.ExecutionStepList>"

venv/lib/python3.11/site-packages/twilio/rest/studio/v2/flow/execution/execution_step/execution_step_context.py

@@ -0,0 +1,231 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Studio
+    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 ExecutionStepContextInstance(InstanceResource):
+
+    """
+    :ivar account_sid: The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the ExecutionStepContext resource.
+    :ivar context: The current state of the Flow's Execution. As a flow executes, we save its state in this context. We save data that your widgets can access as variables in configuration fields or in text areas as variable substitution.
+    :ivar execution_sid: The SID of the context's Execution resource.
+    :ivar flow_sid: The SID of the Flow.
+    :ivar step_sid: The SID of the Step that the context is associated with.
+    :ivar url: The absolute URL of the resource.
+    """
+
+    def __init__(
+        self,
+        version: Version,
+        payload: Dict[str, Any],
+        flow_sid: str,
+        execution_sid: str,
+        step_sid: str,
+    ):
+        super().__init__(version)
+
+        self.account_sid: Optional[str] = payload.get("account_sid")
+        self.context: Optional[Dict[str, object]] = payload.get("context")
+        self.execution_sid: Optional[str] = payload.get("execution_sid")
+        self.flow_sid: Optional[str] = payload.get("flow_sid")
+        self.step_sid: Optional[str] = payload.get("step_sid")
+        self.url: Optional[str] = payload.get("url")
+
+        self._solution = {
+            "flow_sid": flow_sid,
+            "execution_sid": execution_sid,
+            "step_sid": step_sid,
+        }
+        self._context: Optional[ExecutionStepContextContext] = None
+
+    @property
+    def _proxy(self) -> "ExecutionStepContextContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: ExecutionStepContextContext for this ExecutionStepContextInstance
+        """
+        if self._context is None:
+            self._context = ExecutionStepContextContext(
+                self._version,
+                flow_sid=self._solution["flow_sid"],
+                execution_sid=self._solution["execution_sid"],
+                step_sid=self._solution["step_sid"],
+            )
+        return self._context
+
+    def fetch(self) -> "ExecutionStepContextInstance":
+        """
+        Fetch the ExecutionStepContextInstance
+
+
+        :returns: The fetched ExecutionStepContextInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "ExecutionStepContextInstance":
+        """
+        Asynchronous coroutine to fetch the ExecutionStepContextInstance
+
+
+        :returns: The fetched ExecutionStepContextInstance
+        """
+        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.Studio.V2.ExecutionStepContextInstance {}>".format(context)
+
+
+class ExecutionStepContextContext(InstanceContext):
+    def __init__(
+        self, version: Version, flow_sid: str, execution_sid: str, step_sid: str
+    ):
+        """
+        Initialize the ExecutionStepContextContext
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow with the Step to fetch.
+        :param execution_sid: The SID of the Execution resource with the Step to fetch.
+        :param step_sid: The SID of the Step to fetch.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "execution_sid": execution_sid,
+            "step_sid": step_sid,
+        }
+        self._uri = "/Flows/{flow_sid}/Executions/{execution_sid}/Steps/{step_sid}/Context".format(
+            **self._solution
+        )
+
+    def fetch(self) -> ExecutionStepContextInstance:
+        """
+        Fetch the ExecutionStepContextInstance
+
+
+        :returns: The fetched ExecutionStepContextInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return ExecutionStepContextInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+            step_sid=self._solution["step_sid"],
+        )
+
+    async def fetch_async(self) -> ExecutionStepContextInstance:
+        """
+        Asynchronous coroutine to fetch the ExecutionStepContextInstance
+
+
+        :returns: The fetched ExecutionStepContextInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return ExecutionStepContextInstance(
+            self._version,
+            payload,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+            step_sid=self._solution["step_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.Studio.V2.ExecutionStepContextContext {}>".format(context)
+
+
+class ExecutionStepContextList(ListResource):
+    def __init__(
+        self, version: Version, flow_sid: str, execution_sid: str, step_sid: str
+    ):
+        """
+        Initialize the ExecutionStepContextList
+
+        :param version: Version that contains the resource
+        :param flow_sid: The SID of the Flow with the Step to fetch.
+        :param execution_sid: The SID of the Execution resource with the Step to fetch.
+        :param step_sid: The SID of the Step to fetch.
+
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "flow_sid": flow_sid,
+            "execution_sid": execution_sid,
+            "step_sid": step_sid,
+        }
+
+    def get(self) -> ExecutionStepContextContext:
+        """
+        Constructs a ExecutionStepContextContext
+
+        """
+        return ExecutionStepContextContext(
+            self._version,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+            step_sid=self._solution["step_sid"],
+        )
+
+    def __call__(self) -> ExecutionStepContextContext:
+        """
+        Constructs a ExecutionStepContextContext
+
+        """
+        return ExecutionStepContextContext(
+            self._version,
+            flow_sid=self._solution["flow_sid"],
+            execution_sid=self._solution["execution_sid"],
+            step_sid=self._solution["step_sid"],
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V2.ExecutionStepContextList>"

venv/lib/python3.11/site-packages/twilio/rest/studio/v2/flow/flow_revision.py

@@ -0,0 +1,434 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Studio
+    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 FlowRevisionInstance(InstanceResource):
+    class Status(object):
+        DRAFT = "draft"
+        PUBLISHED = "published"
+
+    """
+    :ivar sid: The unique string that we created to identify the Flow resource.
+    :ivar account_sid: The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the Flow resource.
+    :ivar friendly_name: The string that you assigned to describe the Flow.
+    :ivar definition: JSON representation of flow definition.
+    :ivar status: 
+    :ivar revision: The latest revision number of the Flow's definition.
+    :ivar commit_message: Description of change made in the revision.
+    :ivar valid: Boolean if the flow definition is valid.
+    :ivar errors: List of error in the flow definition.
+    :ivar date_created: The date and time in GMT when the resource was created specified in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
+    :ivar date_updated: The date and time in GMT when the resource was last updated specified in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
+    :ivar url: The absolute URL of the resource.
+    """
+
+    def __init__(
+        self,
+        version: Version,
+        payload: Dict[str, Any],
+        sid: str,
+        revision: Optional[str] = None,
+    ):
+        super().__init__(version)
+
+        self.sid: Optional[str] = payload.get("sid")
+        self.account_sid: Optional[str] = payload.get("account_sid")
+        self.friendly_name: Optional[str] = payload.get("friendly_name")
+        self.definition: Optional[Dict[str, object]] = payload.get("definition")
+        self.status: Optional["FlowRevisionInstance.Status"] = payload.get("status")
+        self.revision: Optional[int] = deserialize.integer(payload.get("revision"))
+        self.commit_message: Optional[str] = payload.get("commit_message")
+        self.valid: Optional[bool] = payload.get("valid")
+        self.errors: Optional[List[object]] = payload.get("errors")
+        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 = {
+            "sid": sid,
+            "revision": revision or self.revision,
+        }
+        self._context: Optional[FlowRevisionContext] = None
+
+    @property
+    def _proxy(self) -> "FlowRevisionContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: FlowRevisionContext for this FlowRevisionInstance
+        """
+        if self._context is None:
+            self._context = FlowRevisionContext(
+                self._version,
+                sid=self._solution["sid"],
+                revision=self._solution["revision"],
+            )
+        return self._context
+
+    def fetch(self) -> "FlowRevisionInstance":
+        """
+        Fetch the FlowRevisionInstance
+
+
+        :returns: The fetched FlowRevisionInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "FlowRevisionInstance":
+        """
+        Asynchronous coroutine to fetch the FlowRevisionInstance
+
+
+        :returns: The fetched FlowRevisionInstance
+        """
+        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.Studio.V2.FlowRevisionInstance {}>".format(context)
+
+
+class FlowRevisionContext(InstanceContext):
+    def __init__(self, version: Version, sid: str, revision: str):
+        """
+        Initialize the FlowRevisionContext
+
+        :param version: Version that contains the resource
+        :param sid: The SID of the Flow resource to fetch.
+        :param revision: Specific Revision number or can be `LatestPublished` and `LatestRevision`.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "sid": sid,
+            "revision": revision,
+        }
+        self._uri = "/Flows/{sid}/Revisions/{revision}".format(**self._solution)
+
+    def fetch(self) -> FlowRevisionInstance:
+        """
+        Fetch the FlowRevisionInstance
+
+
+        :returns: The fetched FlowRevisionInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return FlowRevisionInstance(
+            self._version,
+            payload,
+            sid=self._solution["sid"],
+            revision=self._solution["revision"],
+        )
+
+    async def fetch_async(self) -> FlowRevisionInstance:
+        """
+        Asynchronous coroutine to fetch the FlowRevisionInstance
+
+
+        :returns: The fetched FlowRevisionInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return FlowRevisionInstance(
+            self._version,
+            payload,
+            sid=self._solution["sid"],
+            revision=self._solution["revision"],
+        )
+
+    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.Studio.V2.FlowRevisionContext {}>".format(context)
+
+
+class FlowRevisionPage(Page):
+    def get_instance(self, payload: Dict[str, Any]) -> FlowRevisionInstance:
+        """
+        Build an instance of FlowRevisionInstance
+
+        :param payload: Payload response from the API
+        """
+        return FlowRevisionInstance(self._version, payload, sid=self._solution["sid"])
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V2.FlowRevisionPage>"
+
+
+class FlowRevisionList(ListResource):
+    def __init__(self, version: Version, sid: str):
+        """
+        Initialize the FlowRevisionList
+
+        :param version: Version that contains the resource
+        :param sid: The SID of the Flow resource to fetch.
+
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "sid": sid,
+        }
+        self._uri = "/Flows/{sid}/Revisions".format(**self._solution)
+
+    def stream(
+        self,
+        limit: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> Iterator[FlowRevisionInstance]:
+        """
+        Streams FlowRevisionInstance 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[FlowRevisionInstance]:
+        """
+        Asynchronously streams FlowRevisionInstance 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[FlowRevisionInstance]:
+        """
+        Lists FlowRevisionInstance 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[FlowRevisionInstance]:
+        """
+        Asynchronously lists FlowRevisionInstance 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,
+    ) -> FlowRevisionPage:
+        """
+        Retrieve a single page of FlowRevisionInstance 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 FlowRevisionInstance
+        """
+        data = values.of(
+            {
+                "PageToken": page_token,
+                "Page": page_number,
+                "PageSize": page_size,
+            }
+        )
+
+        response = self._version.page(method="GET", uri=self._uri, params=data)
+        return FlowRevisionPage(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,
+    ) -> FlowRevisionPage:
+        """
+        Asynchronously retrieve a single page of FlowRevisionInstance 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 FlowRevisionInstance
+        """
+        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 FlowRevisionPage(self._version, response, self._solution)
+
+    def get_page(self, target_url: str) -> FlowRevisionPage:
+        """
+        Retrieve a specific page of FlowRevisionInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of FlowRevisionInstance
+        """
+        response = self._version.domain.twilio.request("GET", target_url)
+        return FlowRevisionPage(self._version, response, self._solution)
+
+    async def get_page_async(self, target_url: str) -> FlowRevisionPage:
+        """
+        Asynchronously retrieve a specific page of FlowRevisionInstance records from the API.
+        Request is executed immediately
+
+        :param target_url: API-generated URL for the requested results page
+
+        :returns: Page of FlowRevisionInstance
+        """
+        response = await self._version.domain.twilio.request_async("GET", target_url)
+        return FlowRevisionPage(self._version, response, self._solution)
+
+    def get(self, revision: str) -> FlowRevisionContext:
+        """
+        Constructs a FlowRevisionContext
+
+        :param revision: Specific Revision number or can be `LatestPublished` and `LatestRevision`.
+        """
+        return FlowRevisionContext(
+            self._version, sid=self._solution["sid"], revision=revision
+        )
+
+    def __call__(self, revision: str) -> FlowRevisionContext:
+        """
+        Constructs a FlowRevisionContext
+
+        :param revision: Specific Revision number or can be `LatestPublished` and `LatestRevision`.
+        """
+        return FlowRevisionContext(
+            self._version, sid=self._solution["sid"], revision=revision
+        )
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V2.FlowRevisionList>"

venv/lib/python3.11/site-packages/twilio/rest/studio/v2/flow/flow_test_user.py

@@ -0,0 +1,255 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Studio
+    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
+from twilio.base import serialize, 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 FlowTestUserInstance(InstanceResource):
+
+    """
+    :ivar sid: Unique identifier of the flow.
+    :ivar test_users: List of test user identities that can test draft versions of the flow.
+    :ivar url: The URL of this resource.
+    """
+
+    def __init__(self, version: Version, payload: Dict[str, Any], sid: str):
+        super().__init__(version)
+
+        self.sid: Optional[str] = payload.get("sid")
+        self.test_users: Optional[List[str]] = payload.get("test_users")
+        self.url: Optional[str] = payload.get("url")
+
+        self._solution = {
+            "sid": sid,
+        }
+        self._context: Optional[FlowTestUserContext] = None
+
+    @property
+    def _proxy(self) -> "FlowTestUserContext":
+        """
+        Generate an instance context for the instance, the context is capable of
+        performing various actions. All instance actions are proxied to the context
+
+        :returns: FlowTestUserContext for this FlowTestUserInstance
+        """
+        if self._context is None:
+            self._context = FlowTestUserContext(
+                self._version,
+                sid=self._solution["sid"],
+            )
+        return self._context
+
+    def fetch(self) -> "FlowTestUserInstance":
+        """
+        Fetch the FlowTestUserInstance
+
+
+        :returns: The fetched FlowTestUserInstance
+        """
+        return self._proxy.fetch()
+
+    async def fetch_async(self) -> "FlowTestUserInstance":
+        """
+        Asynchronous coroutine to fetch the FlowTestUserInstance
+
+
+        :returns: The fetched FlowTestUserInstance
+        """
+        return await self._proxy.fetch_async()
+
+    def update(self, test_users: List[str]) -> "FlowTestUserInstance":
+        """
+        Update the FlowTestUserInstance
+
+        :param test_users: List of test user identities that can test draft versions of the flow.
+
+        :returns: The updated FlowTestUserInstance
+        """
+        return self._proxy.update(
+            test_users=test_users,
+        )
+
+    async def update_async(self, test_users: List[str]) -> "FlowTestUserInstance":
+        """
+        Asynchronous coroutine to update the FlowTestUserInstance
+
+        :param test_users: List of test user identities that can test draft versions of the flow.
+
+        :returns: The updated FlowTestUserInstance
+        """
+        return await self._proxy.update_async(
+            test_users=test_users,
+        )
+
+    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.Studio.V2.FlowTestUserInstance {}>".format(context)
+
+
+class FlowTestUserContext(InstanceContext):
+    def __init__(self, version: Version, sid: str):
+        """
+        Initialize the FlowTestUserContext
+
+        :param version: Version that contains the resource
+        :param sid: Unique identifier of the flow.
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "sid": sid,
+        }
+        self._uri = "/Flows/{sid}/TestUsers".format(**self._solution)
+
+    def fetch(self) -> FlowTestUserInstance:
+        """
+        Fetch the FlowTestUserInstance
+
+
+        :returns: The fetched FlowTestUserInstance
+        """
+
+        payload = self._version.fetch(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return FlowTestUserInstance(
+            self._version,
+            payload,
+            sid=self._solution["sid"],
+        )
+
+    async def fetch_async(self) -> FlowTestUserInstance:
+        """
+        Asynchronous coroutine to fetch the FlowTestUserInstance
+
+
+        :returns: The fetched FlowTestUserInstance
+        """
+
+        payload = await self._version.fetch_async(
+            method="GET",
+            uri=self._uri,
+        )
+
+        return FlowTestUserInstance(
+            self._version,
+            payload,
+            sid=self._solution["sid"],
+        )
+
+    def update(self, test_users: List[str]) -> FlowTestUserInstance:
+        """
+        Update the FlowTestUserInstance
+
+        :param test_users: List of test user identities that can test draft versions of the flow.
+
+        :returns: The updated FlowTestUserInstance
+        """
+        data = values.of(
+            {
+                "TestUsers": serialize.map(test_users, lambda e: e),
+            }
+        )
+
+        payload = self._version.update(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return FlowTestUserInstance(self._version, payload, sid=self._solution["sid"])
+
+    async def update_async(self, test_users: List[str]) -> FlowTestUserInstance:
+        """
+        Asynchronous coroutine to update the FlowTestUserInstance
+
+        :param test_users: List of test user identities that can test draft versions of the flow.
+
+        :returns: The updated FlowTestUserInstance
+        """
+        data = values.of(
+            {
+                "TestUsers": serialize.map(test_users, lambda e: e),
+            }
+        )
+
+        payload = await self._version.update_async(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return FlowTestUserInstance(self._version, payload, 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.Studio.V2.FlowTestUserContext {}>".format(context)
+
+
+class FlowTestUserList(ListResource):
+    def __init__(self, version: Version, sid: str):
+        """
+        Initialize the FlowTestUserList
+
+        :param version: Version that contains the resource
+        :param sid: Unique identifier of the flow.
+
+        """
+        super().__init__(version)
+
+        # Path Solution
+        self._solution = {
+            "sid": sid,
+        }
+
+    def get(self) -> FlowTestUserContext:
+        """
+        Constructs a FlowTestUserContext
+
+        """
+        return FlowTestUserContext(self._version, sid=self._solution["sid"])
+
+    def __call__(self) -> FlowTestUserContext:
+        """
+        Constructs a FlowTestUserContext
+
+        """
+        return FlowTestUserContext(self._version, sid=self._solution["sid"])
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V2.FlowTestUserList>"

venv/lib/python3.11/site-packages/twilio/rest/studio/v2/flow_validate.py

@@ -0,0 +1,134 @@
+r"""
+    This code was generated by
+   ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+    |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+    |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+
+    Twilio - Studio
+    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 serialize, values
+
+from twilio.base.instance_resource import InstanceResource
+from twilio.base.list_resource import ListResource
+from twilio.base.version import Version
+
+
+class FlowValidateInstance(InstanceResource):
+    class Status(object):
+        DRAFT = "draft"
+        PUBLISHED = "published"
+
+    """
+    :ivar valid: Boolean if the flow definition is valid.
+    """
+
+    def __init__(self, version: Version, payload: Dict[str, Any]):
+        super().__init__(version)
+
+        self.valid: Optional[bool] = payload.get("valid")
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+
+        return "<Twilio.Studio.V2.FlowValidateInstance>"
+
+
+class FlowValidateList(ListResource):
+    def __init__(self, version: Version):
+        """
+        Initialize the FlowValidateList
+
+        :param version: Version that contains the resource
+
+        """
+        super().__init__(version)
+
+        self._uri = "/Flows/Validate"
+
+    def update(
+        self,
+        friendly_name: str,
+        status: "FlowValidateInstance.Status",
+        definition: object,
+        commit_message: Union[str, object] = values.unset,
+    ) -> FlowValidateInstance:
+        """
+        Update the FlowValidateInstance
+
+        :param friendly_name: The string that you assigned to describe the Flow.
+        :param status:
+        :param definition: JSON representation of flow definition.
+        :param commit_message: Description of change made in the revision.
+
+        :returns: The created FlowValidateInstance
+        """
+        data = values.of(
+            {
+                "FriendlyName": friendly_name,
+                "Status": status,
+                "Definition": serialize.object(definition),
+                "CommitMessage": commit_message,
+            }
+        )
+
+        payload = self._version.update(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return FlowValidateInstance(self._version, payload)
+
+    async def update_async(
+        self,
+        friendly_name: str,
+        status: "FlowValidateInstance.Status",
+        definition: object,
+        commit_message: Union[str, object] = values.unset,
+    ) -> FlowValidateInstance:
+        """
+        Asynchronously update the FlowValidateInstance
+
+        :param friendly_name: The string that you assigned to describe the Flow.
+        :param status:
+        :param definition: JSON representation of flow definition.
+        :param commit_message: Description of change made in the revision.
+
+        :returns: The created FlowValidateInstance
+        """
+        data = values.of(
+            {
+                "FriendlyName": friendly_name,
+                "Status": status,
+                "Definition": serialize.object(definition),
+                "CommitMessage": commit_message,
+            }
+        )
+
+        payload = await self._version.update_async(
+            method="POST",
+            uri=self._uri,
+            data=data,
+        )
+
+        return FlowValidateInstance(self._version, payload)
+
+    def __repr__(self) -> str:
+        """
+        Provide a friendly representation
+
+        :returns: Machine friendly representation
+        """
+        return "<Twilio.Studio.V2.FlowValidateList>"