syllable-sdk 0.41.20__py3-none-any.whl → 0.43.1__py3-none-any.whl

syllable_sdk/models/jmespathexpression.py

@@ -0,0 +1,33 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from enum import Enum
+from syllable_sdk.types import BaseModel
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class JMESPathExpressionType(str, Enum):
+    r"""JMESPath expression."""
+
+    JP = "jp"
+    JMESPATH = "jmespath"
+
+
+class JMESPathExpressionTypedDict(TypedDict):
+    r"""See https://jmespath.org/specification.html#grammar"""
+
+    expression: str
+    r"""The expression to evaluate."""
+    type: NotRequired[JMESPathExpressionType]
+    r"""JMESPath expression."""
+
+
+class JMESPathExpression(BaseModel):
+    r"""See https://jmespath.org/specification.html#grammar"""
+
+    expression: str
+    r"""The expression to evaluate."""
+
+    type: Optional[JMESPathExpressionType] = JMESPathExpressionType.JP
+    r"""JMESPath expression."""

syllable_sdk/models/loadtoolfromfiletask.py

@@ -0,0 +1,112 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .contexttaskmetadata import ContextTaskMetadata, ContextTaskMetadataTypedDict
+from .contexttoolinfo import ContextToolInfo, ContextToolInfoTypedDict
+from .variable import Variable, VariableTypedDict
+import pydantic
+from pydantic import model_serializer
+from pydantic.functional_validators import AfterValidator
+from syllable_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from syllable_sdk.utils import validate_const
+from typing import Any, Dict, List, Literal, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+FileTypedDict = TypeAliasType("FileTypedDict", Union[str, List[str]])
+r"""The local path of the tool definition JSON file."""
+
+
+File = TypeAliasType("File", Union[str, List[str]])
+r"""The local path of the tool definition JSON file."""
+
+
+class LoadToolFromFileTaskTypedDict(TypedDict):
+    r"""Bootstraps a tool from a file (for internal developer use only if ENV.local=True)."""
+
+    file: FileTypedDict
+    r"""The local path of the tool definition JSON file."""
+    id: NotRequired[Nullable[str]]
+    r"""A unique identifier for the task."""
+    config: NotRequired[Nullable[Dict[str, Any]]]
+    variables: NotRequired[Nullable[List[VariableTypedDict]]]
+    metadata: NotRequired[Nullable[ContextTaskMetadataTypedDict]]
+    tool: NotRequired[Nullable[ContextToolInfoTypedDict]]
+    type: Literal["import"]
+    version: Literal["v1alpha"]
+
+
+class LoadToolFromFileTask(BaseModel):
+    r"""Bootstraps a tool from a file (for internal developer use only if ENV.local=True)."""
+
+    file: File
+    r"""The local path of the tool definition JSON file."""
+
+    id: OptionalNullable[str] = UNSET
+    r"""A unique identifier for the task."""
+
+    config: OptionalNullable[Dict[str, Any]] = UNSET
+
+    variables: OptionalNullable[List[Variable]] = UNSET
+
+    metadata: OptionalNullable[ContextTaskMetadata] = UNSET
+
+    tool: OptionalNullable[ContextToolInfo] = UNSET
+
+    TYPE: Annotated[
+        Annotated[
+            Optional[Literal["import"]], AfterValidator(validate_const("import"))
+        ],
+        pydantic.Field(alias="type"),
+    ] = "import"
+
+    VERSION: Annotated[
+        Annotated[
+            Optional[Literal["v1alpha"]], AfterValidator(validate_const("v1alpha"))
+        ],
+        pydantic.Field(alias="version"),
+    ] = "v1alpha"
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "id",
+            "config",
+            "variables",
+            "metadata",
+            "tool",
+            "type",
+            "version",
+        ]
+        nullable_fields = ["id", "config", "variables", "metadata", "tool"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

syllable_sdk/models/nextstep.py

@@ -0,0 +1,97 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .caseexpression import CaseExpression, CaseExpressionTypedDict
+from .celexpression import CelExpression, CelExpressionTypedDict
+from .jmespathexpression import JMESPathExpression, JMESPathExpressionTypedDict
+import pydantic
+from pydantic import Discriminator, Tag, model_serializer
+from syllable_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from syllable_sdk.utils import get_discriminator
+from typing import List, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+NextStepIf1TypedDict = TypeAliasType(
+    "NextStepIf1TypedDict", Union[CelExpressionTypedDict, JMESPathExpressionTypedDict]
+)
+
+
+NextStepIf1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+NextStepIf2TypedDict = TypeAliasType(
+    "NextStepIf2TypedDict", Union[CaseExpressionTypedDict, NextStepIf1TypedDict, str]
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+NextStepIf2 = TypeAliasType("NextStepIf2", Union[CaseExpression, NextStepIf1, str])
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+class NextStepTypedDict(TypedDict):
+    r"""Represents a conditional transition to the next step."""
+
+    id: str
+    r"""The identifier of the next step."""
+    if_: NotRequired[Nullable[NextStepIf2TypedDict]]
+    r"""An expression that must evaluate to true for the action to be applied."""
+    requires: NotRequired[Nullable[List[str]]]
+    r"""List of input field names required for this transition. Validates that specified inputs are collected before allowing transition."""
+
+
+class NextStep(BaseModel):
+    r"""Represents a conditional transition to the next step."""
+
+    id: str
+    r"""The identifier of the next step."""
+
+    if_: Annotated[OptionalNullable[NextStepIf2], pydantic.Field(alias="if")] = UNSET
+    r"""An expression that must evaluate to true for the action to be applied."""
+
+    requires: OptionalNullable[List[str]] = UNSET
+    r"""List of input field names required for this transition. Validates that specified inputs are collected before allowing transition."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["if", "requires"]
+        nullable_fields = ["if", "requires"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

syllable_sdk/models/saveaction.py

@@ -0,0 +1,103 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .caseexpression import CaseExpression, CaseExpressionTypedDict
+from .celexpression import CelExpression, CelExpressionTypedDict
+from .jmespathexpression import JMESPathExpression, JMESPathExpressionTypedDict
+import pydantic
+from pydantic import Discriminator, Tag, model_serializer
+from pydantic.functional_validators import AfterValidator
+from syllable_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from syllable_sdk.utils import get_discriminator, validate_const
+from typing import List, Literal, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+SaveActionIf1TypedDict = TypeAliasType(
+    "SaveActionIf1TypedDict", Union[CelExpressionTypedDict, JMESPathExpressionTypedDict]
+)
+
+
+SaveActionIf1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+SaveActionIf2TypedDict = TypeAliasType(
+    "SaveActionIf2TypedDict",
+    Union[CaseExpressionTypedDict, SaveActionIf1TypedDict, str],
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+SaveActionIf2 = TypeAliasType(
+    "SaveActionIf2", Union[CaseExpression, SaveActionIf1, str]
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+class SaveActionTypedDict(TypedDict):
+    if_: NotRequired[Nullable[SaveActionIf2TypedDict]]
+    r"""An expression that must evaluate to true for the action to be applied."""
+    action: Literal["save"]
+    name: NotRequired[Nullable[str]]
+    r"""Target name to save (defaults to global variable)."""
+    inputs: NotRequired[Nullable[List[str]]]
+    r"""Input field names to persist; None saves all collected inputs."""
+
+
+class SaveAction(BaseModel):
+    if_: Annotated[OptionalNullable[SaveActionIf2], pydantic.Field(alias="if")] = UNSET
+    r"""An expression that must evaluate to true for the action to be applied."""
+
+    ACTION: Annotated[
+        Annotated[Optional[Literal["save"]], AfterValidator(validate_const("save"))],
+        pydantic.Field(alias="action"),
+    ] = "save"
+
+    name: OptionalNullable[str] = UNSET
+    r"""Target name to save (defaults to global variable)."""
+
+    inputs: OptionalNullable[List[str]] = UNSET
+    r"""Input field names to persist; None saves all collected inputs."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["if", "action", "name", "inputs"]
+        nullable_fields = ["if", "name", "inputs"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

syllable_sdk/models/sayaction.py

@@ -0,0 +1,108 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .caseexpression import CaseExpression, CaseExpressionTypedDict
+from .celexpression import CelExpression, CelExpressionTypedDict
+from .jmespathexpression import JMESPathExpression, JMESPathExpressionTypedDict
+from enum import Enum
+import pydantic
+from pydantic import Discriminator, Tag, model_serializer
+from pydantic.functional_validators import AfterValidator
+from syllable_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from syllable_sdk.utils import get_discriminator, validate_const
+from typing import Literal, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+SayActionIf1TypedDict = TypeAliasType(
+    "SayActionIf1TypedDict", Union[CelExpressionTypedDict, JMESPathExpressionTypedDict]
+)
+
+
+SayActionIf1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+SayActionIf2TypedDict = TypeAliasType(
+    "SayActionIf2TypedDict", Union[CaseExpressionTypedDict, SayActionIf1TypedDict, str]
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+SayActionIf2 = TypeAliasType("SayActionIf2", Union[CaseExpression, SayActionIf1, str])
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+class Role(str, Enum):
+    r"""The role of the message."""
+
+    USER = "user"
+    ASSISTANT = "assistant"
+
+
+class SayActionTypedDict(TypedDict):
+    text: str
+    r"""Text to apply if the condition is true."""
+    if_: NotRequired[Nullable[SayActionIf2TypedDict]]
+    r"""An expression that must evaluate to true for the action to be applied."""
+    action: Literal["say"]
+    role: NotRequired[Role]
+    r"""The role of the message."""
+
+
+class SayAction(BaseModel):
+    text: str
+    r"""Text to apply if the condition is true."""
+
+    if_: Annotated[OptionalNullable[SayActionIf2], pydantic.Field(alias="if")] = UNSET
+    r"""An expression that must evaluate to true for the action to be applied."""
+
+    ACTION: Annotated[
+        Annotated[Optional[Literal["say"]], AfterValidator(validate_const("say"))],
+        pydantic.Field(alias="action"),
+    ] = "say"
+
+    role: Optional[Role] = Role.ASSISTANT
+    r"""The role of the message."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["if", "action", "role"]
+        nullable_fields = ["if"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

syllable_sdk/models/session.py

@@ -56,6 +56,8 @@ class SessionTypedDict(TypedDict):
     r"""Whether the session occurred on the legacy Syllable system"""
     is_test: NotRequired[Nullable[bool]]
     r"""Whether the session is a test session"""
+    user_terminated: NotRequired[Nullable[bool]]
+    r"""Whether the voice session was ended by the recipient (outbound) / caller (inbound). False if the user was transferred or there was an error. Unset if the session was not a voice session."""
 
 
 class Session(BaseModel):
@@ -121,6 +123,9 @@ class Session(BaseModel):
     is_test: OptionalNullable[bool] = UNSET
     r"""Whether the session is a test session"""
 
+    user_terminated: OptionalNullable[bool] = UNSET
+    r"""Whether the voice session was ended by the recipient (outbound) / caller (inbound). False if the user was transferred or there was an error. Unset if the session was not a voice session."""
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = [
@@ -143,6 +148,7 @@ class Session(BaseModel):
             "target",
             "is_legacy",
             "is_test",
+            "user_terminated",
         ]
         nullable_fields = [
             "session_id",
@@ -164,6 +170,7 @@ class Session(BaseModel):
             "target",
             "is_legacy",
             "is_test",
+            "user_terminated",
         ]
         null_default_fields = []
 

syllable_sdk/models/setvalueaction.py

@@ -0,0 +1,140 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .caseexpression import CaseExpression, CaseExpressionTypedDict
+from .celexpression import CelExpression, CelExpressionTypedDict
+from .jmespathexpression import JMESPathExpression, JMESPathExpressionTypedDict
+import pydantic
+from pydantic import Discriminator, Tag, model_serializer
+from pydantic.functional_validators import AfterValidator
+from syllable_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from syllable_sdk.utils import get_discriminator, validate_const
+from typing import Any, Literal, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+SetValueActionValueFrom1TypedDict = TypeAliasType(
+    "SetValueActionValueFrom1TypedDict",
+    Union[CelExpressionTypedDict, JMESPathExpressionTypedDict],
+)
+
+
+SetValueActionValueFrom1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+SetValueActionValueFrom2TypedDict = TypeAliasType(
+    "SetValueActionValueFrom2TypedDict",
+    Union[CaseExpressionTypedDict, SetValueActionValueFrom1TypedDict, str],
+)
+r"""Expression to compute initial value (mutually exclusive with value)."""
+
+
+SetValueActionValueFrom2 = TypeAliasType(
+    "SetValueActionValueFrom2", Union[CaseExpression, SetValueActionValueFrom1, str]
+)
+r"""Expression to compute initial value (mutually exclusive with value)."""
+
+
+SetValueActionIf1TypedDict = TypeAliasType(
+    "SetValueActionIf1TypedDict",
+    Union[CelExpressionTypedDict, JMESPathExpressionTypedDict],
+)
+
+
+SetValueActionIf1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+SetValueActionIf2TypedDict = TypeAliasType(
+    "SetValueActionIf2TypedDict",
+    Union[CaseExpressionTypedDict, SetValueActionIf1TypedDict, str],
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+SetValueActionIf2 = TypeAliasType(
+    "SetValueActionIf2", Union[CaseExpression, SetValueActionIf1, str]
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+class SetValueActionTypedDict(TypedDict):
+    name: str
+    r"""Destination path to mutate (e.g. output.foo)."""
+    value: NotRequired[Nullable[Any]]
+    r"""Initial value of the variable."""
+    value_from: NotRequired[Nullable[SetValueActionValueFrom2TypedDict]]
+    r"""Expression to compute initial value (mutually exclusive with value)."""
+    if_: NotRequired[Nullable[SetValueActionIf2TypedDict]]
+    r"""An expression that must evaluate to true for the action to be applied."""
+    action: Literal["set"]
+
+
+class SetValueAction(BaseModel):
+    name: str
+    r"""Destination path to mutate (e.g. output.foo)."""
+
+    value: OptionalNullable[Any] = UNSET
+    r"""Initial value of the variable."""
+
+    value_from: OptionalNullable[SetValueActionValueFrom2] = UNSET
+    r"""Expression to compute initial value (mutually exclusive with value)."""
+
+    if_: Annotated[OptionalNullable[SetValueActionIf2], pydantic.Field(alias="if")] = (
+        UNSET
+    )
+    r"""An expression that must evaluate to true for the action to be applied."""
+
+    ACTION: Annotated[
+        Annotated[Optional[Literal["set"]], AfterValidator(validate_const("set"))],
+        pydantic.Field(alias="action"),
+    ] = "set"
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["value", "value_from", "if", "action"]
+        nullable_fields = ["value", "value_from", "if"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

syllable_sdk/models/step.py

@@ -0,0 +1,65 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .conditionaltext import ConditionalText, ConditionalTextTypedDict
+from .inputparameter import InputParameter, InputParameterTypedDict
+from .nextstep import NextStep, NextStepTypedDict
+from .stepeventactions import StepEventActions, StepEventActionsTypedDict
+from .steptools import StepTools, StepToolsTypedDict
+from syllable_sdk.types import BaseModel
+from typing import List, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
+
+
+InstructionTypedDict = TypeAliasType(
+    "InstructionTypedDict", Union[ConditionalTextTypedDict, str]
+)
+
+
+Instruction = TypeAliasType("Instruction", Union[ConditionalText, str])
+
+
+NextTypedDict = TypeAliasType("NextTypedDict", Union[NextStepTypedDict, str])
+
+
+Next = TypeAliasType("Next", Union[NextStep, str])
+
+
+class StepTypedDict(TypedDict):
+    id: str
+    r"""The unique identifier of the step."""
+    goal: str
+    r"""The goal of the step."""
+    instructions: NotRequired[List[InstructionTypedDict]]
+    r"""The instructions for the step."""
+    tools: NotRequired[StepToolsTypedDict]
+    r"""Configuration for tools available in a step."""
+    inputs: NotRequired[List[InputParameterTypedDict]]
+    r"""The inputs for the step."""
+    on: NotRequired[StepEventActionsTypedDict]
+    r"""Actions to perform when events occur (enter, submit)."""
+    next: NotRequired[List[NextTypedDict]]
+    r"""The next steps to execute."""
+
+
+class Step(BaseModel):
+    id: str
+    r"""The unique identifier of the step."""
+
+    goal: str
+    r"""The goal of the step."""
+
+    instructions: Optional[List[Instruction]] = None
+    r"""The instructions for the step."""
+
+    tools: Optional[StepTools] = None
+    r"""Configuration for tools available in a step."""
+
+    inputs: Optional[List[InputParameter]] = None
+    r"""The inputs for the step."""
+
+    on: Optional[StepEventActions] = None
+    r"""Actions to perform when events occur (enter, submit)."""
+
+    next: Optional[List[Next]] = None
+    r"""The next steps to execute."""