"""
@generated by mypy-protobuf.  Do not edit manually!
isort:skip_file
"""

import builtins
import collections.abc
import sys
import typing

import google.protobuf.descriptor
import google.protobuf.internal.containers
import google.protobuf.internal.enum_type_wrapper
import google.protobuf.message

if sys.version_info >= (3, 10):
    import typing as typing_extensions
else:
    import typing_extensions

DESCRIPTOR: google.protobuf.descriptor.FileDescriptor

class _BinaryOperator:
    ValueType = typing.NewType("ValueType", builtins.int)
    V: typing_extensions.TypeAlias = ValueType

class _BinaryOperatorEnumTypeWrapper(
    google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_BinaryOperator.ValueType],
    builtins.type,
):
    DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
    BINARY_OP_UNSPECIFIED: _BinaryOperator.ValueType  # 0
    BINARY_OP_ADD: _BinaryOperator.ValueType  # 1
    """Arithmetic"""
    BINARY_OP_SUB: _BinaryOperator.ValueType  # 2
    BINARY_OP_MUL: _BinaryOperator.ValueType  # 3
    BINARY_OP_DIV: _BinaryOperator.ValueType  # 4
    BINARY_OP_FLOOR_DIV: _BinaryOperator.ValueType  # 5
    BINARY_OP_MOD: _BinaryOperator.ValueType  # 6
    BINARY_OP_EQ: _BinaryOperator.ValueType  # 10
    """Comparison"""
    BINARY_OP_NE: _BinaryOperator.ValueType  # 11
    BINARY_OP_LT: _BinaryOperator.ValueType  # 12
    BINARY_OP_LE: _BinaryOperator.ValueType  # 13
    BINARY_OP_GT: _BinaryOperator.ValueType  # 14
    BINARY_OP_GE: _BinaryOperator.ValueType  # 15
    BINARY_OP_IN: _BinaryOperator.ValueType  # 16
    BINARY_OP_NOT_IN: _BinaryOperator.ValueType  # 17
    BINARY_OP_AND: _BinaryOperator.ValueType  # 20
    """Logical"""
    BINARY_OP_OR: _BinaryOperator.ValueType  # 21

class BinaryOperator(_BinaryOperator, metaclass=_BinaryOperatorEnumTypeWrapper): ...

BINARY_OP_UNSPECIFIED: BinaryOperator.ValueType  # 0
BINARY_OP_ADD: BinaryOperator.ValueType  # 1
"""Arithmetic"""
BINARY_OP_SUB: BinaryOperator.ValueType  # 2
BINARY_OP_MUL: BinaryOperator.ValueType  # 3
BINARY_OP_DIV: BinaryOperator.ValueType  # 4
BINARY_OP_FLOOR_DIV: BinaryOperator.ValueType  # 5
BINARY_OP_MOD: BinaryOperator.ValueType  # 6
BINARY_OP_EQ: BinaryOperator.ValueType  # 10
"""Comparison"""
BINARY_OP_NE: BinaryOperator.ValueType  # 11
BINARY_OP_LT: BinaryOperator.ValueType  # 12
BINARY_OP_LE: BinaryOperator.ValueType  # 13
BINARY_OP_GT: BinaryOperator.ValueType  # 14
BINARY_OP_GE: BinaryOperator.ValueType  # 15
BINARY_OP_IN: BinaryOperator.ValueType  # 16
BINARY_OP_NOT_IN: BinaryOperator.ValueType  # 17
BINARY_OP_AND: BinaryOperator.ValueType  # 20
"""Logical"""
BINARY_OP_OR: BinaryOperator.ValueType  # 21
Global___BinaryOperator: typing_extensions.TypeAlias = BinaryOperator

class _UnaryOperator:
    ValueType = typing.NewType("ValueType", builtins.int)
    V: typing_extensions.TypeAlias = ValueType

class _UnaryOperatorEnumTypeWrapper(
    google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_UnaryOperator.ValueType],
    builtins.type,
):
    DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
    UNARY_OP_UNSPECIFIED: _UnaryOperator.ValueType  # 0
    UNARY_OP_NEG: _UnaryOperator.ValueType  # 1
    UNARY_OP_NOT: _UnaryOperator.ValueType  # 2

class UnaryOperator(_UnaryOperator, metaclass=_UnaryOperatorEnumTypeWrapper): ...

UNARY_OP_UNSPECIFIED: UnaryOperator.ValueType  # 0
UNARY_OP_NEG: UnaryOperator.ValueType  # 1
UNARY_OP_NOT: UnaryOperator.ValueType  # 2
Global___UnaryOperator: typing_extensions.TypeAlias = UnaryOperator

class _GlobalFunction:
    ValueType = typing.NewType("ValueType", builtins.int)
    V: typing_extensions.TypeAlias = ValueType

class _GlobalFunctionEnumTypeWrapper(
    google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_GlobalFunction.ValueType],
    builtins.type,
):
    DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
    GLOBAL_FUNCTION_UNSPECIFIED: _GlobalFunction.ValueType  # 0
    GLOBAL_FUNCTION_RANGE: _GlobalFunction.ValueType  # 1
    GLOBAL_FUNCTION_LEN: _GlobalFunction.ValueType  # 2
    GLOBAL_FUNCTION_ENUMERATE: _GlobalFunction.ValueType  # 3
    GLOBAL_FUNCTION_ISEXCEPTION: _GlobalFunction.ValueType  # 4

class GlobalFunction(_GlobalFunction, metaclass=_GlobalFunctionEnumTypeWrapper):
    """Global (built-in) functions supported by the runtime."""

GLOBAL_FUNCTION_UNSPECIFIED: GlobalFunction.ValueType  # 0
GLOBAL_FUNCTION_RANGE: GlobalFunction.ValueType  # 1
GLOBAL_FUNCTION_LEN: GlobalFunction.ValueType  # 2
GLOBAL_FUNCTION_ENUMERATE: GlobalFunction.ValueType  # 3
GLOBAL_FUNCTION_ISEXCEPTION: GlobalFunction.ValueType  # 4
Global___GlobalFunction: typing_extensions.TypeAlias = GlobalFunction

@typing.final
class Program(google.protobuf.message.Message):
    """-----------------------------------------------------------------------------
    Top-Level Structure
    -----------------------------------------------------------------------------

    A complete Waymark program (one or more function definitions)
    """

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    FUNCTIONS_FIELD_NUMBER: builtins.int
    @property
    def functions(
        self,
    ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[
        Global___FunctionDef
    ]: ...
    def __init__(
        self,
        *,
        functions: collections.abc.Iterable[Global___FunctionDef] | None = ...,
    ) -> None: ...
    def ClearField(self, field_name: typing.Literal["functions", b"functions"]) -> None: ...

Global___Program: typing_extensions.TypeAlias = Program

@typing.final
class FunctionDef(google.protobuf.message.Message):
    """Function definition with explicit input/output declarations"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    NAME_FIELD_NUMBER: builtins.int
    IO_FIELD_NUMBER: builtins.int
    BODY_FIELD_NUMBER: builtins.int
    SPAN_FIELD_NUMBER: builtins.int
    name: builtins.str
    @property
    def io(self) -> Global___IoDecl: ...
    @property
    def body(self) -> Global___Block: ...
    @property
    def span(self) -> Global___Span: ...
    def __init__(
        self,
        *,
        name: builtins.str = ...,
        io: Global___IoDecl | None = ...,
        body: Global___Block | None = ...,
        span: Global___Span | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing.Literal["body", b"body", "io", b"io", "span", b"span"]
    ) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal["body", b"body", "io", b"io", "name", b"name", "span", b"span"],
    ) -> None: ...

Global___FunctionDef: typing_extensions.TypeAlias = FunctionDef

@typing.final
class IoDecl(google.protobuf.message.Message):
    """Input/output declaration: fn foo(input: [a, b], output: [c])"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    INPUTS_FIELD_NUMBER: builtins.int
    OUTPUTS_FIELD_NUMBER: builtins.int
    SPAN_FIELD_NUMBER: builtins.int
    @property
    def inputs(
        self,
    ) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]: ...
    @property
    def outputs(
        self,
    ) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]: ...
    @property
    def span(self) -> Global___Span: ...
    def __init__(
        self,
        *,
        inputs: collections.abc.Iterable[builtins.str] | None = ...,
        outputs: collections.abc.Iterable[builtins.str] | None = ...,
        span: Global___Span | None = ...,
    ) -> None: ...
    def HasField(self, field_name: typing.Literal["span", b"span"]) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal["inputs", b"inputs", "outputs", b"outputs", "span", b"span"],
    ) -> None: ...

Global___IoDecl: typing_extensions.TypeAlias = IoDecl

@typing.final
class Block(google.protobuf.message.Message):
    """A block of statements (function body - no call restrictions)"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    STATEMENTS_FIELD_NUMBER: builtins.int
    SPAN_FIELD_NUMBER: builtins.int
    @property
    def statements(
        self,
    ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[
        Global___Statement
    ]: ...
    @property
    def span(self) -> Global___Span: ...
    def __init__(
        self,
        *,
        statements: collections.abc.Iterable[Global___Statement] | None = ...,
        span: Global___Span | None = ...,
    ) -> None: ...
    def HasField(self, field_name: typing.Literal["span", b"span"]) -> builtins.bool: ...
    def ClearField(
        self, field_name: typing.Literal["span", b"span", "statements", b"statements"]
    ) -> None: ...

Global___Block: typing_extensions.TypeAlias = Block

@typing.final
class Statement(google.protobuf.message.Message):
    """-----------------------------------------------------------------------------
    Statements
    -----------------------------------------------------------------------------
    """

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    ASSIGNMENT_FIELD_NUMBER: builtins.int
    ACTION_CALL_FIELD_NUMBER: builtins.int
    SPREAD_ACTION_FIELD_NUMBER: builtins.int
    PARALLEL_BLOCK_FIELD_NUMBER: builtins.int
    FOR_LOOP_FIELD_NUMBER: builtins.int
    CONDITIONAL_FIELD_NUMBER: builtins.int
    TRY_EXCEPT_FIELD_NUMBER: builtins.int
    RETURN_STMT_FIELD_NUMBER: builtins.int
    EXPR_STMT_FIELD_NUMBER: builtins.int
    BREAK_STMT_FIELD_NUMBER: builtins.int
    CONTINUE_STMT_FIELD_NUMBER: builtins.int
    WHILE_LOOP_FIELD_NUMBER: builtins.int
    SLEEP_STMT_FIELD_NUMBER: builtins.int
    SPAN_FIELD_NUMBER: builtins.int
    @property
    def assignment(self) -> Global___Assignment: ...
    @property
    def action_call(self) -> Global___ActionCall: ...
    @property
    def spread_action(self) -> Global___SpreadAction: ...
    @property
    def parallel_block(self) -> Global___ParallelBlock: ...
    @property
    def for_loop(self) -> Global___ForLoop: ...
    @property
    def conditional(self) -> Global___Conditional: ...
    @property
    def try_except(self) -> Global___TryExcept: ...
    @property
    def return_stmt(self) -> Global___ReturnStmt: ...
    @property
    def expr_stmt(self) -> Global___ExprStmt: ...
    @property
    def break_stmt(self) -> Global___BreakStmt: ...
    @property
    def continue_stmt(self) -> Global___ContinueStmt: ...
    @property
    def while_loop(self) -> Global___WhileLoop: ...
    @property
    def sleep_stmt(self) -> Global___SleepStmt: ...
    @property
    def span(self) -> Global___Span: ...
    def __init__(
        self,
        *,
        assignment: Global___Assignment | None = ...,
        action_call: Global___ActionCall | None = ...,
        spread_action: Global___SpreadAction | None = ...,
        parallel_block: Global___ParallelBlock | None = ...,
        for_loop: Global___ForLoop | None = ...,
        conditional: Global___Conditional | None = ...,
        try_except: Global___TryExcept | None = ...,
        return_stmt: Global___ReturnStmt | None = ...,
        expr_stmt: Global___ExprStmt | None = ...,
        break_stmt: Global___BreakStmt | None = ...,
        continue_stmt: Global___ContinueStmt | None = ...,
        while_loop: Global___WhileLoop | None = ...,
        sleep_stmt: Global___SleepStmt | None = ...,
        span: Global___Span | None = ...,
    ) -> None: ...
    def HasField(
        self,
        field_name: typing.Literal[
            "action_call",
            b"action_call",
            "assignment",
            b"assignment",
            "break_stmt",
            b"break_stmt",
            "conditional",
            b"conditional",
            "continue_stmt",
            b"continue_stmt",
            "expr_stmt",
            b"expr_stmt",
            "for_loop",
            b"for_loop",
            "kind",
            b"kind",
            "parallel_block",
            b"parallel_block",
            "return_stmt",
            b"return_stmt",
            "sleep_stmt",
            b"sleep_stmt",
            "span",
            b"span",
            "spread_action",
            b"spread_action",
            "try_except",
            b"try_except",
            "while_loop",
            b"while_loop",
        ],
    ) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "action_call",
            b"action_call",
            "assignment",
            b"assignment",
            "break_stmt",
            b"break_stmt",
            "conditional",
            b"conditional",
            "continue_stmt",
            b"continue_stmt",
            "expr_stmt",
            b"expr_stmt",
            "for_loop",
            b"for_loop",
            "kind",
            b"kind",
            "parallel_block",
            b"parallel_block",
            "return_stmt",
            b"return_stmt",
            "sleep_stmt",
            b"sleep_stmt",
            "span",
            b"span",
            "spread_action",
            b"spread_action",
            "try_except",
            b"try_except",
            "while_loop",
            b"while_loop",
        ],
    ) -> None: ...
    def WhichOneof(
        self, oneof_group: typing.Literal["kind", b"kind"]
    ) -> (
        typing.Literal[
            "assignment",
            "action_call",
            "spread_action",
            "parallel_block",
            "for_loop",
            "conditional",
            "try_except",
            "return_stmt",
            "expr_stmt",
            "break_stmt",
            "continue_stmt",
            "while_loop",
            "sleep_stmt",
        ]
        | None
    ): ...

Global___Statement: typing_extensions.TypeAlias = Statement

@typing.final
class BreakStmt(google.protobuf.message.Message):
    """Break statement (exits innermost loop)"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    def __init__(
        self,
    ) -> None: ...

Global___BreakStmt: typing_extensions.TypeAlias = BreakStmt

@typing.final
class ContinueStmt(google.protobuf.message.Message):
    """Continue statement (skips to next iteration of innermost loop)"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    def __init__(
        self,
    ) -> None: ...

Global___ContinueStmt: typing_extensions.TypeAlias = ContinueStmt

@typing.final
class Assignment(google.protobuf.message.Message):
    """Variable assignment: x = expr"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    TARGETS_FIELD_NUMBER: builtins.int
    VALUE_FIELD_NUMBER: builtins.int
    @property
    def targets(
        self,
    ) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
        """Single variable or tuple unpacking (a, b = expr)"""

    @property
    def value(self) -> Global___Expr: ...
    def __init__(
        self,
        *,
        targets: collections.abc.Iterable[builtins.str] | None = ...,
        value: Global___Expr | None = ...,
    ) -> None: ...
    def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ...
    def ClearField(
        self, field_name: typing.Literal["targets", b"targets", "value", b"value"]
    ) -> None: ...

Global___Assignment: typing_extensions.TypeAlias = Assignment

@typing.final
class ActionCall(google.protobuf.message.Message):
    """Action call: @action(kwargs) [retry_policy] [timeout]
    Can be used as:
    - Statement (side effect only): @notify(user=x)
    - Expression in Assignment (with binding): result = @fetch(id=x)
    - Expression in Assignment (with unpacking): a, b = @get_pair()
    """

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    ACTION_NAME_FIELD_NUMBER: builtins.int
    KWARGS_FIELD_NUMBER: builtins.int
    POLICIES_FIELD_NUMBER: builtins.int
    MODULE_NAME_FIELD_NUMBER: builtins.int
    action_name: builtins.str
    module_name: builtins.str
    """Python module containing the action"""
    @property
    def kwargs(
        self,
    ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[Global___Kwarg]: ...
    @property
    def policies(
        self,
    ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[
        Global___PolicyBracket
    ]: ...
    def __init__(
        self,
        *,
        action_name: builtins.str = ...,
        kwargs: collections.abc.Iterable[Global___Kwarg] | None = ...,
        policies: collections.abc.Iterable[Global___PolicyBracket] | None = ...,
        module_name: builtins.str | None = ...,
    ) -> None: ...
    def HasField(
        self,
        field_name: typing.Literal["_module_name", b"_module_name", "module_name", b"module_name"],
    ) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "_module_name",
            b"_module_name",
            "action_name",
            b"action_name",
            "kwargs",
            b"kwargs",
            "module_name",
            b"module_name",
            "policies",
            b"policies",
        ],
    ) -> None: ...
    def WhichOneof(
        self, oneof_group: typing.Literal["_module_name", b"_module_name"]
    ) -> typing.Literal["module_name"] | None: ...

Global___ActionCall: typing_extensions.TypeAlias = ActionCall

@typing.final
class SpreadAction(google.protobuf.message.Message):
    """Spread action statement (side effect only, no result capture)
    For result capture, use Assignment with SpreadExpr
    """

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    COLLECTION_FIELD_NUMBER: builtins.int
    LOOP_VAR_FIELD_NUMBER: builtins.int
    ACTION_FIELD_NUMBER: builtins.int
    loop_var: builtins.str
    """Variable name for each item"""
    @property
    def collection(self) -> Global___Expr:
        """The collection to iterate"""

    @property
    def action(self) -> Global___ActionCall:
        """The action to call per item"""

    def __init__(
        self,
        *,
        collection: Global___Expr | None = ...,
        loop_var: builtins.str = ...,
        action: Global___ActionCall | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing.Literal["action", b"action", "collection", b"collection"]
    ) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "action", b"action", "collection", b"collection", "loop_var", b"loop_var"
        ],
    ) -> None: ...

Global___SpreadAction: typing_extensions.TypeAlias = SpreadAction

@typing.final
class ParallelBlock(google.protobuf.message.Message):
    """Parallel block statement (side effect only, no result capture)
    For result capture, use Assignment with ParallelExpr
    """

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    CALLS_FIELD_NUMBER: builtins.int
    @property
    def calls(
        self,
    ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[Global___Call]:
        """Actions or function calls to run in parallel"""

    def __init__(
        self,
        *,
        calls: collections.abc.Iterable[Global___Call] | None = ...,
    ) -> None: ...
    def ClearField(self, field_name: typing.Literal["calls", b"calls"]) -> None: ...

Global___ParallelBlock: typing_extensions.TypeAlias = ParallelBlock

@typing.final
class Call(google.protobuf.message.Message):
    """A call that can be either action or function (for parallel blocks)"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    ACTION_FIELD_NUMBER: builtins.int
    FUNCTION_FIELD_NUMBER: builtins.int
    @property
    def action(self) -> Global___ActionCall: ...
    @property
    def function(self) -> Global___FunctionCall: ...
    def __init__(
        self,
        *,
        action: Global___ActionCall | None = ...,
        function: Global___FunctionCall | None = ...,
    ) -> None: ...
    def HasField(
        self,
        field_name: typing.Literal["action", b"action", "function", b"function", "kind", b"kind"],
    ) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal["action", b"action", "function", b"function", "kind", b"kind"],
    ) -> None: ...
    def WhichOneof(
        self, oneof_group: typing.Literal["kind", b"kind"]
    ) -> typing.Literal["action", "function"] | None: ...

Global___Call: typing_extensions.TypeAlias = Call

@typing.final
class ForLoop(google.protobuf.message.Message):
    """For loop: for item in items: ..."""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    LOOP_VARS_FIELD_NUMBER: builtins.int
    ITERABLE_FIELD_NUMBER: builtins.int
    BLOCK_BODY_FIELD_NUMBER: builtins.int
    @property
    def loop_vars(
        self,
    ) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
        """Loop variable(s) for unpacking"""

    @property
    def iterable(self) -> Global___Expr: ...
    @property
    def block_body(self) -> Global___Block: ...
    def __init__(
        self,
        *,
        loop_vars: collections.abc.Iterable[builtins.str] | None = ...,
        iterable: Global___Expr | None = ...,
        block_body: Global___Block | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing.Literal["block_body", b"block_body", "iterable", b"iterable"]
    ) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "block_body", b"block_body", "iterable", b"iterable", "loop_vars", b"loop_vars"
        ],
    ) -> None: ...

Global___ForLoop: typing_extensions.TypeAlias = ForLoop

@typing.final
class WhileLoop(google.protobuf.message.Message):
    """While loop: while condition: ..."""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    CONDITION_FIELD_NUMBER: builtins.int
    BLOCK_BODY_FIELD_NUMBER: builtins.int
    @property
    def condition(self) -> Global___Expr: ...
    @property
    def block_body(self) -> Global___Block: ...
    def __init__(
        self,
        *,
        condition: Global___Expr | None = ...,
        block_body: Global___Block | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing.Literal["block_body", b"block_body", "condition", b"condition"]
    ) -> builtins.bool: ...
    def ClearField(
        self, field_name: typing.Literal["block_body", b"block_body", "condition", b"condition"]
    ) -> None: ...

Global___WhileLoop: typing_extensions.TypeAlias = WhileLoop

@typing.final
class Conditional(google.protobuf.message.Message):
    """Conditional: if/elif/else"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    IF_BRANCH_FIELD_NUMBER: builtins.int
    ELIF_BRANCHES_FIELD_NUMBER: builtins.int
    ELSE_BRANCH_FIELD_NUMBER: builtins.int
    @property
    def if_branch(self) -> Global___IfBranch: ...
    @property
    def elif_branches(
        self,
    ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[
        Global___ElifBranch
    ]: ...
    @property
    def else_branch(self) -> Global___ElseBranch: ...
    def __init__(
        self,
        *,
        if_branch: Global___IfBranch | None = ...,
        elif_branches: collections.abc.Iterable[Global___ElifBranch] | None = ...,
        else_branch: Global___ElseBranch | None = ...,
    ) -> None: ...
    def HasField(
        self,
        field_name: typing.Literal[
            "_else_branch",
            b"_else_branch",
            "else_branch",
            b"else_branch",
            "if_branch",
            b"if_branch",
        ],
    ) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "_else_branch",
            b"_else_branch",
            "elif_branches",
            b"elif_branches",
            "else_branch",
            b"else_branch",
            "if_branch",
            b"if_branch",
        ],
    ) -> None: ...
    def WhichOneof(
        self, oneof_group: typing.Literal["_else_branch", b"_else_branch"]
    ) -> typing.Literal["else_branch"] | None: ...

Global___Conditional: typing_extensions.TypeAlias = Conditional

@typing.final
class IfBranch(google.protobuf.message.Message):
    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    CONDITION_FIELD_NUMBER: builtins.int
    SPAN_FIELD_NUMBER: builtins.int
    BLOCK_BODY_FIELD_NUMBER: builtins.int
    @property
    def condition(self) -> Global___Expr: ...
    @property
    def span(self) -> Global___Span: ...
    @property
    def block_body(self) -> Global___Block: ...
    def __init__(
        self,
        *,
        condition: Global___Expr | None = ...,
        span: Global___Span | None = ...,
        block_body: Global___Block | None = ...,
    ) -> None: ...
    def HasField(
        self,
        field_name: typing.Literal[
            "block_body", b"block_body", "condition", b"condition", "span", b"span"
        ],
    ) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "block_body", b"block_body", "condition", b"condition", "span", b"span"
        ],
    ) -> None: ...

Global___IfBranch: typing_extensions.TypeAlias = IfBranch

@typing.final
class ElifBranch(google.protobuf.message.Message):
    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    CONDITION_FIELD_NUMBER: builtins.int
    SPAN_FIELD_NUMBER: builtins.int
    BLOCK_BODY_FIELD_NUMBER: builtins.int
    @property
    def condition(self) -> Global___Expr: ...
    @property
    def span(self) -> Global___Span: ...
    @property
    def block_body(self) -> Global___Block: ...
    def __init__(
        self,
        *,
        condition: Global___Expr | None = ...,
        span: Global___Span | None = ...,
        block_body: Global___Block | None = ...,
    ) -> None: ...
    def HasField(
        self,
        field_name: typing.Literal[
            "block_body", b"block_body", "condition", b"condition", "span", b"span"
        ],
    ) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "block_body", b"block_body", "condition", b"condition", "span", b"span"
        ],
    ) -> None: ...

Global___ElifBranch: typing_extensions.TypeAlias = ElifBranch

@typing.final
class ElseBranch(google.protobuf.message.Message):
    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    SPAN_FIELD_NUMBER: builtins.int
    BLOCK_BODY_FIELD_NUMBER: builtins.int
    @property
    def span(self) -> Global___Span: ...
    @property
    def block_body(self) -> Global___Block: ...
    def __init__(
        self,
        *,
        span: Global___Span | None = ...,
        block_body: Global___Block | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing.Literal["block_body", b"block_body", "span", b"span"]
    ) -> builtins.bool: ...
    def ClearField(
        self, field_name: typing.Literal["block_body", b"block_body", "span", b"span"]
    ) -> None: ...

Global___ElseBranch: typing_extensions.TypeAlias = ElseBranch

@typing.final
class TryExcept(google.protobuf.message.Message):
    """Try/except block"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    HANDLERS_FIELD_NUMBER: builtins.int
    TRY_BLOCK_FIELD_NUMBER: builtins.int
    @property
    def handlers(
        self,
    ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[
        Global___ExceptHandler
    ]: ...
    @property
    def try_block(self) -> Global___Block: ...
    def __init__(
        self,
        *,
        handlers: collections.abc.Iterable[Global___ExceptHandler] | None = ...,
        try_block: Global___Block | None = ...,
    ) -> None: ...
    def HasField(self, field_name: typing.Literal["try_block", b"try_block"]) -> builtins.bool: ...
    def ClearField(
        self, field_name: typing.Literal["handlers", b"handlers", "try_block", b"try_block"]
    ) -> None: ...

Global___TryExcept: typing_extensions.TypeAlias = TryExcept

@typing.final
class ExceptHandler(google.protobuf.message.Message):
    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    EXCEPTION_TYPES_FIELD_NUMBER: builtins.int
    SPAN_FIELD_NUMBER: builtins.int
    BLOCK_BODY_FIELD_NUMBER: builtins.int
    EXCEPTION_VAR_FIELD_NUMBER: builtins.int
    exception_var: builtins.str
    """Variable name for "except ... as var" """
    @property
    def exception_types(
        self,
    ) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
        """Empty = catch all"""

    @property
    def span(self) -> Global___Span: ...
    @property
    def block_body(self) -> Global___Block: ...
    def __init__(
        self,
        *,
        exception_types: collections.abc.Iterable[builtins.str] | None = ...,
        span: Global___Span | None = ...,
        block_body: Global___Block | None = ...,
        exception_var: builtins.str | None = ...,
    ) -> None: ...
    def HasField(
        self,
        field_name: typing.Literal[
            "_exception_var",
            b"_exception_var",
            "block_body",
            b"block_body",
            "exception_var",
            b"exception_var",
            "span",
            b"span",
        ],
    ) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "_exception_var",
            b"_exception_var",
            "block_body",
            b"block_body",
            "exception_types",
            b"exception_types",
            "exception_var",
            b"exception_var",
            "span",
            b"span",
        ],
    ) -> None: ...
    def WhichOneof(
        self, oneof_group: typing.Literal["_exception_var", b"_exception_var"]
    ) -> typing.Literal["exception_var"] | None: ...

Global___ExceptHandler: typing_extensions.TypeAlias = ExceptHandler

@typing.final
class ReturnStmt(google.protobuf.message.Message):
    """Return statement"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    VALUE_FIELD_NUMBER: builtins.int
    @property
    def value(self) -> Global___Expr: ...
    def __init__(
        self,
        *,
        value: Global___Expr | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing.Literal["_value", b"_value", "value", b"value"]
    ) -> builtins.bool: ...
    def ClearField(
        self, field_name: typing.Literal["_value", b"_value", "value", b"value"]
    ) -> None: ...
    def WhichOneof(
        self, oneof_group: typing.Literal["_value", b"_value"]
    ) -> typing.Literal["value"] | None: ...

Global___ReturnStmt: typing_extensions.TypeAlias = ReturnStmt

@typing.final
class ExprStmt(google.protobuf.message.Message):
    """Expression as statement"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    EXPR_FIELD_NUMBER: builtins.int
    @property
    def expr(self) -> Global___Expr: ...
    def __init__(
        self,
        *,
        expr: Global___Expr | None = ...,
    ) -> None: ...
    def HasField(self, field_name: typing.Literal["expr", b"expr"]) -> builtins.bool: ...
    def ClearField(self, field_name: typing.Literal["expr", b"expr"]) -> None: ...

Global___ExprStmt: typing_extensions.TypeAlias = ExprStmt

@typing.final
class SleepStmt(google.protobuf.message.Message):
    """Sleep statement (durable sleep handled by scheduler)"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    DURATION_FIELD_NUMBER: builtins.int
    @property
    def duration(self) -> Global___Expr: ...
    def __init__(
        self,
        *,
        duration: Global___Expr | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing.Literal["_duration", b"_duration", "duration", b"duration"]
    ) -> builtins.bool: ...
    def ClearField(
        self, field_name: typing.Literal["_duration", b"_duration", "duration", b"duration"]
    ) -> None: ...
    def WhichOneof(
        self, oneof_group: typing.Literal["_duration", b"_duration"]
    ) -> typing.Literal["duration"] | None: ...

Global___SleepStmt: typing_extensions.TypeAlias = SleepStmt

@typing.final
class Expr(google.protobuf.message.Message):
    """-----------------------------------------------------------------------------
    Expressions
    -----------------------------------------------------------------------------
    """

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    LITERAL_FIELD_NUMBER: builtins.int
    VARIABLE_FIELD_NUMBER: builtins.int
    BINARY_OP_FIELD_NUMBER: builtins.int
    UNARY_OP_FIELD_NUMBER: builtins.int
    LIST_FIELD_NUMBER: builtins.int
    DICT_FIELD_NUMBER: builtins.int
    INDEX_FIELD_NUMBER: builtins.int
    DOT_FIELD_NUMBER: builtins.int
    FUNCTION_CALL_FIELD_NUMBER: builtins.int
    ACTION_CALL_FIELD_NUMBER: builtins.int
    PARALLEL_EXPR_FIELD_NUMBER: builtins.int
    SPREAD_EXPR_FIELD_NUMBER: builtins.int
    SPAN_FIELD_NUMBER: builtins.int
    @property
    def literal(self) -> Global___Literal: ...
    @property
    def variable(self) -> Global___Variable: ...
    @property
    def binary_op(self) -> Global___BinaryOp: ...
    @property
    def unary_op(self) -> Global___UnaryOp: ...
    @property
    def list(self) -> Global___ListExpr: ...
    @property
    def dict(self) -> Global___DictExpr: ...
    @property
    def index(self) -> Global___IndexAccess: ...
    @property
    def dot(self) -> Global___DotAccess: ...
    @property
    def function_call(self) -> Global___FunctionCall: ...
    @property
    def action_call(self) -> Global___ActionCall: ...
    @property
    def parallel_expr(self) -> Global___ParallelExpr:
        """Parallel block as expression"""

    @property
    def spread_expr(self) -> Global___SpreadExpr:
        """Spread action as expression"""

    @property
    def span(self) -> Global___Span: ...
    def __init__(
        self,
        *,
        literal: Global___Literal | None = ...,
        variable: Global___Variable | None = ...,
        binary_op: Global___BinaryOp | None = ...,
        unary_op: Global___UnaryOp | None = ...,
        list: Global___ListExpr | None = ...,
        dict: Global___DictExpr | None = ...,
        index: Global___IndexAccess | None = ...,
        dot: Global___DotAccess | None = ...,
        function_call: Global___FunctionCall | None = ...,
        action_call: Global___ActionCall | None = ...,
        parallel_expr: Global___ParallelExpr | None = ...,
        spread_expr: Global___SpreadExpr | None = ...,
        span: Global___Span | None = ...,
    ) -> None: ...
    def HasField(
        self,
        field_name: typing.Literal[
            "action_call",
            b"action_call",
            "binary_op",
            b"binary_op",
            "dict",
            b"dict",
            "dot",
            b"dot",
            "function_call",
            b"function_call",
            "index",
            b"index",
            "kind",
            b"kind",
            "list",
            b"list",
            "literal",
            b"literal",
            "parallel_expr",
            b"parallel_expr",
            "span",
            b"span",
            "spread_expr",
            b"spread_expr",
            "unary_op",
            b"unary_op",
            "variable",
            b"variable",
        ],
    ) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "action_call",
            b"action_call",
            "binary_op",
            b"binary_op",
            "dict",
            b"dict",
            "dot",
            b"dot",
            "function_call",
            b"function_call",
            "index",
            b"index",
            "kind",
            b"kind",
            "list",
            b"list",
            "literal",
            b"literal",
            "parallel_expr",
            b"parallel_expr",
            "span",
            b"span",
            "spread_expr",
            b"spread_expr",
            "unary_op",
            b"unary_op",
            "variable",
            b"variable",
        ],
    ) -> None: ...
    def WhichOneof(
        self, oneof_group: typing.Literal["kind", b"kind"]
    ) -> (
        typing.Literal[
            "literal",
            "variable",
            "binary_op",
            "unary_op",
            "list",
            "dict",
            "index",
            "dot",
            "function_call",
            "action_call",
            "parallel_expr",
            "spread_expr",
        ]
        | None
    ): ...

Global___Expr: typing_extensions.TypeAlias = Expr

@typing.final
class Literal(google.protobuf.message.Message):
    """Literals: 42, 3.14, "hello", True, False"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    INT_VALUE_FIELD_NUMBER: builtins.int
    FLOAT_VALUE_FIELD_NUMBER: builtins.int
    STRING_VALUE_FIELD_NUMBER: builtins.int
    BOOL_VALUE_FIELD_NUMBER: builtins.int
    IS_NONE_FIELD_NUMBER: builtins.int
    int_value: builtins.int
    float_value: builtins.float
    string_value: builtins.str
    bool_value: builtins.bool
    is_none: builtins.bool
    """true if None"""
    def __init__(
        self,
        *,
        int_value: builtins.int = ...,
        float_value: builtins.float = ...,
        string_value: builtins.str = ...,
        bool_value: builtins.bool = ...,
        is_none: builtins.bool = ...,
    ) -> None: ...
    def HasField(
        self,
        field_name: typing.Literal[
            "bool_value",
            b"bool_value",
            "float_value",
            b"float_value",
            "int_value",
            b"int_value",
            "is_none",
            b"is_none",
            "string_value",
            b"string_value",
            "value",
            b"value",
        ],
    ) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "bool_value",
            b"bool_value",
            "float_value",
            b"float_value",
            "int_value",
            b"int_value",
            "is_none",
            b"is_none",
            "string_value",
            b"string_value",
            "value",
            b"value",
        ],
    ) -> None: ...
    def WhichOneof(
        self, oneof_group: typing.Literal["value", b"value"]
    ) -> (
        typing.Literal["int_value", "float_value", "string_value", "bool_value", "is_none"] | None
    ): ...

Global___Literal: typing_extensions.TypeAlias = Literal

@typing.final
class Variable(google.protobuf.message.Message):
    """Variable reference: foo"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    NAME_FIELD_NUMBER: builtins.int
    name: builtins.str
    def __init__(
        self,
        *,
        name: builtins.str = ...,
    ) -> None: ...
    def ClearField(self, field_name: typing.Literal["name", b"name"]) -> None: ...

Global___Variable: typing_extensions.TypeAlias = Variable

@typing.final
class BinaryOp(google.protobuf.message.Message):
    """Binary operation: a + b, x and y, etc."""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    LEFT_FIELD_NUMBER: builtins.int
    OP_FIELD_NUMBER: builtins.int
    RIGHT_FIELD_NUMBER: builtins.int
    op: Global___BinaryOperator.ValueType
    @property
    def left(self) -> Global___Expr: ...
    @property
    def right(self) -> Global___Expr: ...
    def __init__(
        self,
        *,
        left: Global___Expr | None = ...,
        op: Global___BinaryOperator.ValueType = ...,
        right: Global___Expr | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing.Literal["left", b"left", "right", b"right"]
    ) -> builtins.bool: ...
    def ClearField(
        self, field_name: typing.Literal["left", b"left", "op", b"op", "right", b"right"]
    ) -> None: ...

Global___BinaryOp: typing_extensions.TypeAlias = BinaryOp

@typing.final
class UnaryOp(google.protobuf.message.Message):
    """Unary operation: -x, not x"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    OP_FIELD_NUMBER: builtins.int
    OPERAND_FIELD_NUMBER: builtins.int
    op: Global___UnaryOperator.ValueType
    @property
    def operand(self) -> Global___Expr: ...
    def __init__(
        self,
        *,
        op: Global___UnaryOperator.ValueType = ...,
        operand: Global___Expr | None = ...,
    ) -> None: ...
    def HasField(self, field_name: typing.Literal["operand", b"operand"]) -> builtins.bool: ...
    def ClearField(
        self, field_name: typing.Literal["op", b"op", "operand", b"operand"]
    ) -> None: ...

Global___UnaryOp: typing_extensions.TypeAlias = UnaryOp

@typing.final
class ListExpr(google.protobuf.message.Message):
    """List literal: [1, 2, 3]"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    ELEMENTS_FIELD_NUMBER: builtins.int
    @property
    def elements(
        self,
    ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[Global___Expr]: ...
    def __init__(
        self,
        *,
        elements: collections.abc.Iterable[Global___Expr] | None = ...,
    ) -> None: ...
    def ClearField(self, field_name: typing.Literal["elements", b"elements"]) -> None: ...

Global___ListExpr: typing_extensions.TypeAlias = ListExpr

@typing.final
class DictExpr(google.protobuf.message.Message):
    """Dict literal: {"a": 1, "b": 2}"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    ENTRIES_FIELD_NUMBER: builtins.int
    @property
    def entries(
        self,
    ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[
        Global___DictEntry
    ]: ...
    def __init__(
        self,
        *,
        entries: collections.abc.Iterable[Global___DictEntry] | None = ...,
    ) -> None: ...
    def ClearField(self, field_name: typing.Literal["entries", b"entries"]) -> None: ...

Global___DictExpr: typing_extensions.TypeAlias = DictExpr

@typing.final
class DictEntry(google.protobuf.message.Message):
    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    KEY_FIELD_NUMBER: builtins.int
    VALUE_FIELD_NUMBER: builtins.int
    @property
    def key(self) -> Global___Expr: ...
    @property
    def value(self) -> Global___Expr: ...
    def __init__(
        self,
        *,
        key: Global___Expr | None = ...,
        value: Global___Expr | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing.Literal["key", b"key", "value", b"value"]
    ) -> builtins.bool: ...
    def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ...

Global___DictEntry: typing_extensions.TypeAlias = DictEntry

@typing.final
class IndexAccess(google.protobuf.message.Message):
    """Index access: items[0]"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    OBJECT_FIELD_NUMBER: builtins.int
    INDEX_FIELD_NUMBER: builtins.int
    @property
    def object(self) -> Global___Expr: ...
    @property
    def index(self) -> Global___Expr: ...
    def __init__(
        self,
        *,
        object: Global___Expr | None = ...,
        index: Global___Expr | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing.Literal["index", b"index", "object", b"object"]
    ) -> builtins.bool: ...
    def ClearField(
        self, field_name: typing.Literal["index", b"index", "object", b"object"]
    ) -> None: ...

Global___IndexAccess: typing_extensions.TypeAlias = IndexAccess

@typing.final
class DotAccess(google.protobuf.message.Message):
    """Dot access: obj.attr"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    OBJECT_FIELD_NUMBER: builtins.int
    ATTRIBUTE_FIELD_NUMBER: builtins.int
    attribute: builtins.str
    @property
    def object(self) -> Global___Expr: ...
    def __init__(
        self,
        *,
        object: Global___Expr | None = ...,
        attribute: builtins.str = ...,
    ) -> None: ...
    def HasField(self, field_name: typing.Literal["object", b"object"]) -> builtins.bool: ...
    def ClearField(
        self, field_name: typing.Literal["attribute", b"attribute", "object", b"object"]
    ) -> None: ...

Global___DotAccess: typing_extensions.TypeAlias = DotAccess

@typing.final
class FunctionCall(google.protobuf.message.Message):
    """Function call: range(10), len(items)
    Built-in functions can use positional args, user functions use kwargs
    """

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    NAME_FIELD_NUMBER: builtins.int
    ARGS_FIELD_NUMBER: builtins.int
    KWARGS_FIELD_NUMBER: builtins.int
    GLOBAL_FUNCTION_FIELD_NUMBER: builtins.int
    name: builtins.str
    global_function: Global___GlobalFunction.ValueType
    """Global function identifier (if applicable)"""
    @property
    def args(
        self,
    ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[Global___Expr]:
        """Positional arguments (for built-ins)"""

    @property
    def kwargs(
        self,
    ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[Global___Kwarg]:
        """Keyword arguments"""

    def __init__(
        self,
        *,
        name: builtins.str = ...,
        args: collections.abc.Iterable[Global___Expr] | None = ...,
        kwargs: collections.abc.Iterable[Global___Kwarg] | None = ...,
        global_function: Global___GlobalFunction.ValueType = ...,
    ) -> None: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "args",
            b"args",
            "global_function",
            b"global_function",
            "kwargs",
            b"kwargs",
            "name",
            b"name",
        ],
    ) -> None: ...

Global___FunctionCall: typing_extensions.TypeAlias = FunctionCall

@typing.final
class Kwarg(google.protobuf.message.Message):
    """Keyword argument: name=value"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    NAME_FIELD_NUMBER: builtins.int
    VALUE_FIELD_NUMBER: builtins.int
    name: builtins.str
    @property
    def value(self) -> Global___Expr: ...
    def __init__(
        self,
        *,
        name: builtins.str = ...,
        value: Global___Expr | None = ...,
    ) -> None: ...
    def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ...
    def ClearField(
        self, field_name: typing.Literal["name", b"name", "value", b"value"]
    ) -> None: ...

Global___Kwarg: typing_extensions.TypeAlias = Kwarg

@typing.final
class ParallelExpr(google.protobuf.message.Message):
    """Parallel expression: concurrent execution of multiple calls, returns list
    Used in assignments: a, b = parallel: @x() @y()
    """

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    CALLS_FIELD_NUMBER: builtins.int
    @property
    def calls(
        self,
    ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[Global___Call]:
        """Actions or function calls to run in parallel"""

    def __init__(
        self,
        *,
        calls: collections.abc.Iterable[Global___Call] | None = ...,
    ) -> None: ...
    def ClearField(self, field_name: typing.Literal["calls", b"calls"]) -> None: ...

Global___ParallelExpr: typing_extensions.TypeAlias = ParallelExpr

@typing.final
class SpreadExpr(google.protobuf.message.Message):
    """Spread expression: parallel execution over a collection, returns list
    Used in assignments: results = spread items:item -> @action(item=item)
    """

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    COLLECTION_FIELD_NUMBER: builtins.int
    LOOP_VAR_FIELD_NUMBER: builtins.int
    ACTION_FIELD_NUMBER: builtins.int
    loop_var: builtins.str
    """Variable name for each item"""
    @property
    def collection(self) -> Global___Expr:
        """The collection to iterate"""

    @property
    def action(self) -> Global___ActionCall:
        """The action to call per item"""

    def __init__(
        self,
        *,
        collection: Global___Expr | None = ...,
        loop_var: builtins.str = ...,
        action: Global___ActionCall | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing.Literal["action", b"action", "collection", b"collection"]
    ) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "action", b"action", "collection", b"collection", "loop_var", b"loop_var"
        ],
    ) -> None: ...

Global___SpreadExpr: typing_extensions.TypeAlias = SpreadExpr

@typing.final
class PolicyBracket(google.protobuf.message.Message):
    """-----------------------------------------------------------------------------
    Policies (for actions)
    -----------------------------------------------------------------------------

    Policy bracket on an action call
    """

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    RETRY_FIELD_NUMBER: builtins.int
    TIMEOUT_FIELD_NUMBER: builtins.int
    @property
    def retry(self) -> Global___RetryPolicy: ...
    @property
    def timeout(self) -> Global___TimeoutPolicy: ...
    def __init__(
        self,
        *,
        retry: Global___RetryPolicy | None = ...,
        timeout: Global___TimeoutPolicy | None = ...,
    ) -> None: ...
    def HasField(
        self, field_name: typing.Literal["kind", b"kind", "retry", b"retry", "timeout", b"timeout"]
    ) -> builtins.bool: ...
    def ClearField(
        self, field_name: typing.Literal["kind", b"kind", "retry", b"retry", "timeout", b"timeout"]
    ) -> None: ...
    def WhichOneof(
        self, oneof_group: typing.Literal["kind", b"kind"]
    ) -> typing.Literal["retry", "timeout"] | None: ...

Global___PolicyBracket: typing_extensions.TypeAlias = PolicyBracket

@typing.final
class RetryPolicy(google.protobuf.message.Message):
    """Retry policy: [ExceptionType -> retry: 3, backoff: 60s]"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    EXCEPTION_TYPES_FIELD_NUMBER: builtins.int
    MAX_RETRIES_FIELD_NUMBER: builtins.int
    BACKOFF_FIELD_NUMBER: builtins.int
    max_retries: builtins.int
    @property
    def exception_types(
        self,
    ) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
        """Empty = catch all"""

    @property
    def backoff(self) -> Global___Duration: ...
    def __init__(
        self,
        *,
        exception_types: collections.abc.Iterable[builtins.str] | None = ...,
        max_retries: builtins.int = ...,
        backoff: Global___Duration | None = ...,
    ) -> None: ...
    def HasField(self, field_name: typing.Literal["backoff", b"backoff"]) -> builtins.bool: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "backoff",
            b"backoff",
            "exception_types",
            b"exception_types",
            "max_retries",
            b"max_retries",
        ],
    ) -> None: ...

Global___RetryPolicy: typing_extensions.TypeAlias = RetryPolicy

@typing.final
class TimeoutPolicy(google.protobuf.message.Message):
    """Timeout policy: [timeout: 2m]"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    TIMEOUT_FIELD_NUMBER: builtins.int
    @property
    def timeout(self) -> Global___Duration: ...
    def __init__(
        self,
        *,
        timeout: Global___Duration | None = ...,
    ) -> None: ...
    def HasField(self, field_name: typing.Literal["timeout", b"timeout"]) -> builtins.bool: ...
    def ClearField(self, field_name: typing.Literal["timeout", b"timeout"]) -> None: ...

Global___TimeoutPolicy: typing_extensions.TypeAlias = TimeoutPolicy

@typing.final
class Duration(google.protobuf.message.Message):
    """Duration value (e.g., 30s, 2m, 1h)"""

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    SECONDS_FIELD_NUMBER: builtins.int
    seconds: builtins.int
    def __init__(
        self,
        *,
        seconds: builtins.int = ...,
    ) -> None: ...
    def ClearField(self, field_name: typing.Literal["seconds", b"seconds"]) -> None: ...

Global___Duration: typing_extensions.TypeAlias = Duration

@typing.final
class Span(google.protobuf.message.Message):
    """-----------------------------------------------------------------------------
    Source Location
    -----------------------------------------------------------------------------

    Source span for error reporting
    """

    DESCRIPTOR: google.protobuf.descriptor.Descriptor

    START_LINE_FIELD_NUMBER: builtins.int
    START_COL_FIELD_NUMBER: builtins.int
    END_LINE_FIELD_NUMBER: builtins.int
    END_COL_FIELD_NUMBER: builtins.int
    start_line: builtins.int
    start_col: builtins.int
    end_line: builtins.int
    end_col: builtins.int
    def __init__(
        self,
        *,
        start_line: builtins.int = ...,
        start_col: builtins.int = ...,
        end_line: builtins.int = ...,
        end_col: builtins.int = ...,
    ) -> None: ...
    def ClearField(
        self,
        field_name: typing.Literal[
            "end_col",
            b"end_col",
            "end_line",
            b"end_line",
            "start_col",
            b"start_col",
            "start_line",
            b"start_line",
        ],
    ) -> None: ...

Global___Span: typing_extensions.TypeAlias = Span
