"""
Auto-generated Python stub file from ast.stmts.py
Module: ast.stmts
"""


import t, c
from stdint import *
import memhub
import string
from .base import AST, ASTKind, ASTCtx, OpKind, _init_ast, _copy_str, _set_parent_list, _emit, _emit_str, _emit_int, _dump_list, FLAG_IS_ASYNC

@t.CVTable
class Module(AST):
    def __new__(self: Module, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
    def __init__(self: Module, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
    def kind(self: Module) -> t.CInt: pass
    def type_name(self: Module) -> str: pass
    def dump(self: Module, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Assign(AST):
    targets: list[AST | t.CPtr] | t.CPtr
    value: AST | t.CPtr
    def __new__(self: Assign, pool: memhub.MemManager | t.CPtr, targets: list[AST | t.CPtr] | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
    def __init__(self: Assign, pool: memhub.MemManager | t.CPtr, targets: list[AST | t.CPtr] | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
    def kind(self: Assign) -> t.CInt: pass
    def type_name(self: Assign) -> str: pass
    def dump(self: Assign, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class If(AST):
    test: AST | t.CPtr
    orelse: list[AST | t.CPtr] | t.CPtr
    def __new__(self: If, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
    def __init__(self: If, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
    def kind(self: If) -> t.CInt: pass
    def type_name(self: If) -> str: pass
    def dump(self: If, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class For(AST):
    target: AST | t.CPtr
    iter: AST | t.CPtr
    orelse: list[AST | t.CPtr] | t.CPtr
    flags: t.CInt
    def __new__(self: For, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, iter: AST | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr, is_async: t.CInt) -> t.CInt: pass
    def __init__(self: For, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, iter: AST | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr, is_async: t.CInt) -> t.CInt: pass
    def kind(self: For) -> t.CInt: pass
    def type_name(self: For) -> str: pass
    def dump(self: For, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class While(AST):
    test: AST | t.CPtr
    orelse: list[AST | t.CPtr] | t.CPtr
    def __new__(self: While, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
    def __init__(self: While, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
    def kind(self: While) -> t.CInt: pass
    def type_name(self: While) -> str: pass
    def dump(self: While, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Return(AST):
    value: AST | t.CPtr
    def __new__(self: Return, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
    def __init__(self: Return, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
    def kind(self: Return) -> t.CInt: pass
    def type_name(self: Return) -> str: pass
    def dump(self: Return, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Expr(AST):
    value: AST | t.CPtr
    def __new__(self: Expr, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
    def __init__(self: Expr, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr) -> t.CInt: pass
    def kind(self: Expr) -> t.CInt: pass
    def type_name(self: Expr) -> str: pass
    def dump(self: Expr, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class FunctionDef(AST):
    name: str
    args: AST | t.CPtr
    decorator_list: list[AST | t.CPtr] | t.CPtr
    returns: AST | t.CPtr
    flags: t.CInt
    def __new__(self: FunctionDef, pool: memhub.MemManager | t.CPtr, name: str, args: AST | t.CPtr, decorator_list: list[AST | t.CPtr] | t.CPtr, returns: AST | t.CPtr, is_async: t.CInt) -> t.CInt: pass
    def __init__(self: FunctionDef, pool: memhub.MemManager | t.CPtr, name: str, args: AST | t.CPtr, decorator_list: list[AST | t.CPtr] | t.CPtr, returns: AST | t.CPtr, is_async: t.CInt) -> t.CInt: pass
    def kind(self: FunctionDef) -> t.CInt: pass
    def type_name(self: FunctionDef) -> str: pass
    def dump(self: FunctionDef, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Expression(AST):
    body: AST | t.CPtr
    def __new__(self: Expression, pool: memhub.MemManager | t.CPtr, body: AST | t.CPtr) -> t.CInt: pass
    def __init__(self: Expression, pool: memhub.MemManager | t.CPtr, body: AST | t.CPtr) -> t.CInt: pass
    def kind(self: Expression) -> t.CInt: pass
    def type_name(self: Expression) -> str: pass
    def dump(self: Expression, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Interactive(AST):
    body: AST | t.CPtr
    def __new__(self: Interactive, pool: memhub.MemManager | t.CPtr, body: AST | t.CPtr) -> t.CInt: pass
    def __init__(self: Interactive, pool: memhub.MemManager | t.CPtr, body: AST | t.CPtr) -> t.CInt: pass
    def kind(self: Interactive) -> t.CInt: pass
    def type_name(self: Interactive) -> str: pass
    def dump(self: Interactive, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class FunctionType(AST):
    argtypes: list[AST | t.CPtr] | t.CPtr
    returns: AST | t.CPtr
    def __new__(self: FunctionType, pool: memhub.MemManager | t.CPtr, argtypes: list[AST | t.CPtr] | t.CPtr, returns: AST | t.CPtr) -> t.CInt: pass
    def __init__(self: FunctionType, pool: memhub.MemManager | t.CPtr, argtypes: list[AST | t.CPtr] | t.CPtr, returns: AST | t.CPtr) -> t.CInt: pass
    def kind(self: FunctionType) -> t.CInt: pass
    def type_name(self: FunctionType) -> str: pass
    def dump(self: FunctionType, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class ClassDef(AST):
    name: str
    bases: list[AST | t.CPtr] | t.CPtr
    keywords: list[AST | t.CPtr] | t.CPtr
    decorator_list: list[AST | t.CPtr] | t.CPtr
    type_params: list[str] | t.CPtr
    def __new__(self: ClassDef, pool: memhub.MemManager | t.CPtr, name: str, bases: list[AST | t.CPtr] | t.CPtr, keywords: list[AST | t.CPtr] | t.CPtr, decorator_list: list[AST | t.CPtr] | t.CPtr, type_params: list[str] | t.CPtr) -> t.CInt: pass
    def __init__(self: ClassDef, pool: memhub.MemManager | t.CPtr, name: str, bases: list[AST | t.CPtr] | t.CPtr, keywords: list[AST | t.CPtr] | t.CPtr, decorator_list: list[AST | t.CPtr] | t.CPtr, type_params: list[str] | t.CPtr) -> t.CInt: pass
    def kind(self: ClassDef) -> t.CInt: pass
    def type_name(self: ClassDef) -> str: pass
    def dump(self: ClassDef, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Delete(AST):
    targets: list[AST | t.CPtr] | t.CPtr
    def __new__(self: Delete, pool: memhub.MemManager | t.CPtr, targets: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
    def __init__(self: Delete, pool: memhub.MemManager | t.CPtr, targets: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
    def kind(self: Delete) -> t.CInt: pass
    def type_name(self: Delete) -> str: pass
    def dump(self: Delete, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class AugAssign(AST):
    target: AST | t.CPtr
    op: t.CInt
    value: AST | t.CPtr
    def __new__(self: AugAssign, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, op: t.CInt, value: AST | t.CPtr) -> t.CInt: pass
    def __init__(self: AugAssign, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, op: t.CInt, value: AST | t.CPtr) -> t.CInt: pass
    def kind(self: AugAssign) -> t.CInt: pass
    def type_name(self: AugAssign) -> str: pass
    def dump(self: AugAssign, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class AnnAssign(AST):
    target: AST | t.CPtr
    annotation: AST | t.CPtr
    value: AST | t.CPtr
    simple: t.CInt
    def __new__(self: AnnAssign, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, annotation: AST | t.CPtr, value: AST | t.CPtr, simple: t.CInt) -> t.CInt: pass
    def __init__(self: AnnAssign, pool: memhub.MemManager | t.CPtr, target: AST | t.CPtr, annotation: AST | t.CPtr, value: AST | t.CPtr, simple: t.CInt) -> t.CInt: pass
    def kind(self: AnnAssign) -> t.CInt: pass
    def type_name(self: AnnAssign) -> str: pass
    def dump(self: AnnAssign, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class With(AST):
    items: list[AST | t.CPtr] | t.CPtr
    flags: t.CInt
    def __new__(self: With, pool: memhub.MemManager | t.CPtr, items: list[AST | t.CPtr] | t.CPtr, is_async: t.CInt) -> t.CInt: pass
    def __init__(self: With, pool: memhub.MemManager | t.CPtr, items: list[AST | t.CPtr] | t.CPtr, is_async: t.CInt) -> t.CInt: pass
    def kind(self: With) -> t.CInt: pass
    def type_name(self: With) -> str: pass
    def dump(self: With, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Raise(AST):
    exc: AST | t.CPtr
    cause: AST | t.CPtr
    def __new__(self: Raise, pool: memhub.MemManager | t.CPtr, exc: AST | t.CPtr, cause: AST | t.CPtr) -> t.CInt: pass
    def __init__(self: Raise, pool: memhub.MemManager | t.CPtr, exc: AST | t.CPtr, cause: AST | t.CPtr) -> t.CInt: pass
    def kind(self: Raise) -> t.CInt: pass
    def type_name(self: Raise) -> str: pass
    def dump(self: Raise, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Try(AST):
    handlers: list[AST | t.CPtr] | t.CPtr
    orelse: list[AST | t.CPtr] | t.CPtr
    finalbody: list[AST | t.CPtr] | t.CPtr
    def __new__(self: Try, pool: memhub.MemManager | t.CPtr, handlers: list[AST | t.CPtr] | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr, finalbody: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
    def __init__(self: Try, pool: memhub.MemManager | t.CPtr, handlers: list[AST | t.CPtr] | t.CPtr, orelse: list[AST | t.CPtr] | t.CPtr, finalbody: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
    def kind(self: Try) -> t.CInt: pass
    def type_name(self: Try) -> str: pass
    def dump(self: Try, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Assert(AST):
    test: AST | t.CPtr
    msg: AST | t.CPtr
    def __new__(self: Assert, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, msg: AST | t.CPtr) -> t.CInt: pass
    def __init__(self: Assert, pool: memhub.MemManager | t.CPtr, test: AST | t.CPtr, msg: AST | t.CPtr) -> t.CInt: pass
    def kind(self: Assert) -> t.CInt: pass
    def type_name(self: Assert) -> str: pass
    def dump(self: Assert, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Global(AST):
    names: list[AST | t.CPtr] | t.CPtr
    def __new__(self: Global, pool: memhub.MemManager | t.CPtr, names: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
    def __init__(self: Global, pool: memhub.MemManager | t.CPtr, names: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
    def kind(self: Global) -> t.CInt: pass
    def type_name(self: Global) -> str: pass
    def dump(self: Global, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Nonlocal(AST):
    names: list[AST | t.CPtr] | t.CPtr
    def __new__(self: Nonlocal, pool: memhub.MemManager | t.CPtr, names: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
    def __init__(self: Nonlocal, pool: memhub.MemManager | t.CPtr, names: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
    def kind(self: Nonlocal) -> t.CInt: pass
    def type_name(self: Nonlocal) -> str: pass
    def dump(self: Nonlocal, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Pass(AST):
    def __new__(self: Pass, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
    def __init__(self: Pass, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
    def kind(self: Pass) -> t.CInt: pass
    def type_name(self: Pass) -> str: pass
    def dump(self: Pass, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Break(AST):
    def __new__(self: Break, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
    def __init__(self: Break, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
    def kind(self: Break) -> t.CInt: pass
    def type_name(self: Break) -> str: pass
    def dump(self: Break, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Continue(AST):
    def __new__(self: Continue, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
    def __init__(self: Continue, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
    def kind(self: Continue) -> t.CInt: pass
    def type_name(self: Continue) -> str: pass
    def dump(self: Continue, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Import(AST):
    names: list[AST | t.CPtr] | t.CPtr
    def __new__(self: Import, pool: memhub.MemManager | t.CPtr, names: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
    def __init__(self: Import, pool: memhub.MemManager | t.CPtr, names: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
    def kind(self: Import) -> t.CInt: pass
    def type_name(self: Import) -> str: pass
    def dump(self: Import, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class ImportFrom(AST):
    module: str
    names: list[AST | t.CPtr] | t.CPtr
    level: t.CInt
    def __new__(self: ImportFrom, pool: memhub.MemManager | t.CPtr, module: str, names: list[AST | t.CPtr] | t.CPtr, level: t.CInt) -> t.CInt: pass
    def __init__(self: ImportFrom, pool: memhub.MemManager | t.CPtr, module: str, names: list[AST | t.CPtr] | t.CPtr, level: t.CInt) -> t.CInt: pass
    def kind(self: ImportFrom) -> t.CInt: pass
    def type_name(self: ImportFrom) -> str: pass
    def dump(self: ImportFrom, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass
class Match(AST):
    subject: AST | t.CPtr
    cases: list[AST | t.CPtr] | t.CPtr
    def __new__(self: Match, pool: memhub.MemManager | t.CPtr, subject: AST | t.CPtr, cases: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
    def __init__(self: Match, pool: memhub.MemManager | t.CPtr, subject: AST | t.CPtr, cases: list[AST | t.CPtr] | t.CPtr) -> t.CInt: pass
    def kind(self: Match) -> t.CInt: pass
    def type_name(self: Match) -> str: pass
    def dump(self: Match, buf: t.CChar | t.CPtr, size: t.CSizeT, pos: t.CSizeT) -> t.CSizeT: pass