Initial commit: Email alerts application

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>"