hydra-typescript
  • hydra
    • hydra namespace
      • Subpackages
        • hydra.type_script namespace
          • Submodules
            • hydra.type_script.coder module
              • analyze_type_script_function()
              • collect_forall_params()
              • collect_imports()
              • collect_inner_type_imports()
              • collect_term_imports()
              • eager_free_variables_in_term()
              • encode_binding_as_statement()
              • encode_lazy_call()
              • encode_literal()
              • encode_literal_type()
              • encode_param()
              • encode_term()
              • encode_term_definition()
              • encode_type()
              • encode_type_definition()
              • encode_type_or_any()
              • filter_non_local_names()
              • flatten_application()
              • force_lazy_refs()
              • function_declaration_from_term()
              • imports_to_text()
              • lazy_flags_for_primitive()
              • let_binding_is_thunk_candidate()
              • mk_doc_comment()
              • module_to_type_script()
              • print_interface_declaration()
              • print_literal()
              • print_module_item()
              • print_property_signature()
              • print_type_alias_declaration()
              • print_type_expression()
              • print_type_parameter()
              • print_type_parameter_list()
              • sanitize_param_name()
              • sort_bindings_topologically()
              • sort_term_defs_topologically()
              • strip_foralls()
              • term_head_variable()
              • thunk_lazy_bindings()
              • thunk_lazy_let()
              • ts_array()
              • ts_arrow()
              • ts_arrow_typed()
              • ts_as_any()
              • ts_call()
              • ts_cond()
              • ts_doc_entity_ref()
              • ts_env_get_graph()
              • ts_env_set_graph()
              • ts_escape_string()
              • ts_expr_ident()
              • ts_expr_str()
              • ts_ident()
              • ts_member()
              • ts_named_type()
              • ts_new()
              • ts_object()
              • ts_param()
              • ts_param_app1()
              • ts_param_app2()
              • ts_paren()
              • ts_prop_sig()
              • ts_prop_sig_with_doc()
              • ts_readonly_map()
              • ts_readonly_set()
              • ts_tuple()
              • ts_typed_ident()
              • ts_undefined()
            • hydra.type_script.language module
              • type_script_language()
              • type_script_reserved_words()
            • hydra.type_script.operators module
              • add_op()
              • arrow_op()
              • assign_op()
              • bitwise_and_op()
              • bitwise_or_op()
              • bitwise_xor_op()
              • colon_op()
              • comma_op()
              • define_op()
              • divide_op()
              • equal_op()
              • exponentiate_op()
              • greater_than_op()
              • greater_than_or_equal_op()
              • in_op()
              • instance_of_op()
              • left_shift_op()
              • less_than_op()
              • less_than_or_equal_op()
              • logical_and_op()
              • logical_or_op()
              • modulo_op()
              • multiply_op()
              • not_equal_op()
              • nullish_coalescing_op()
              • right_shift_op()
              • strict_equal_op()
              • strict_not_equal_op()
              • subtract_op()
              • ternary_op()
              • unsigned_right_shift_op()
            • hydra.type_script.serde module
              • all_digits()
              • array_element_to_expr()
              • array_expression_to_expr()
              • array_pattern_to_expr()
              • arrow_function_expression_to_expr()
              • assignment_expression_to_expr()
              • assignment_operator_to_string()
              • assignment_pattern_to_expr()
              • binary_expression_to_expr()
              • binary_operator_to_expr()
              • block_statement_to_expr()
              • break_statement_to_expr()
              • call_expression_to_expr()
              • catch_clause_to_expr()
              • class_declaration_to_expr()
              • class_declaration_with_comments_to_expr()
              • conditional_expression_to_expr()
              • continue_statement_to_expr()
              • do_while_statement_to_expr()
              • documentation_comment_to_expr()
              • documentation_tag_to_line()
              • escape_string()
              • export_all_to_expr()
              • export_declaration_to_expr()
              • export_specifier_to_expr()
              • expression_to_expr()
              • for_in_statement_to_expr()
              • for_of_statement_to_expr()
              • for_statement_to_expr()
              • format_import_specifiers()
              • function_declaration_to_expr()
              • function_declaration_with_comments_to_expr()
              • function_expression_to_expr()
              • identifier_to_expr()
              • if_statement_to_expr()
              • import_declaration_to_expr()
              • import_specifier_to_expr()
              • is_kernel_type_var_name()
              • labeled_statement_to_expr()
              • literal_to_expr()
              • member_expression_to_expr()
              • method_definition_to_expr()
              • module_item_to_expr()
              • module_item_with_comments_to_expr()
              • named_export_to_expr()
              • numeric_literal_to_expr()
              • object_expression_to_expr()
              • object_pattern_property_to_expr()
              • object_pattern_to_expr()
              • pattern_to_expr()
              • pattern_to_string()
              • program_to_expr()
              • property_to_expr()
              • return_statement_to_expr()
              • statement_to_expr()
              • string_literal_to_expr()
              • switch_case_to_expr()
              • switch_statement_to_expr()
              • template_literal_to_expr()
              • throw_statement_to_expr()
              • to_line_comment()
              • to_type_script_comments()
              • try_statement_to_expr()
              • ts_type_expression_to_string()
              • type_expression_to_string()
              • typed_pattern_to_expr()
              • unary_expression_to_expr()
              • unary_operator_to_string()
              • variable_declaration_to_expr()
              • variable_declarator_to_expr()
              • variable_kind_to_expr()
              • while_statement_to_expr()
            • hydra.type_script.syntax module
              • ArrayElement
                • ArrayElement.EXPRESSION
                • ArrayElement.HOLE
                • ArrayElement.SPREAD
                • ArrayElement.TYPE_
              • ArrayElementExpression
              • ArrayElementHole
              • ArrayElementSpread
              • ArrayTypeExpression
                • ArrayTypeExpression.TYPE_
              • ArrowFunctionBody
                • ArrowFunctionBody.BLOCK
                • ArrowFunctionBody.EXPRESSION
                • ArrowFunctionBody.TYPE_
              • ArrowFunctionBodyBlock
              • ArrowFunctionBodyExpression
              • ArrowFunctionExpression
                • ArrowFunctionExpression.ASYNC
                • ArrowFunctionExpression.BODY
                • ArrowFunctionExpression.Builder
                  • ArrowFunctionExpression.Builder.async_()
                  • ArrowFunctionExpression.Builder.body()
                  • ArrowFunctionExpression.Builder.build()
                  • ArrowFunctionExpression.Builder.params()
                • ArrowFunctionExpression.PARAMS
                • ArrowFunctionExpression.TYPE_
                • ArrowFunctionExpression.async_
                • ArrowFunctionExpression.body
                • ArrowFunctionExpression.builder()
                • ArrowFunctionExpression.params
                • ArrowFunctionExpression.with_async_()
                • ArrowFunctionExpression.with_body()
                • ArrowFunctionExpression.with_params()
              • AsExpression
                • AsExpression.Builder
                  • AsExpression.Builder.build()
                  • AsExpression.Builder.expression()
                  • AsExpression.Builder.type()
                • AsExpression.EXPRESSION
                • AsExpression.TYPE
                • AsExpression.TYPE_
                • AsExpression.builder()
                • AsExpression.expression
                • AsExpression.type
                • AsExpression.with_expression()
                • AsExpression.with_type()
              • AssignmentExpression
                • AssignmentExpression.Builder
                  • AssignmentExpression.Builder.build()
                  • AssignmentExpression.Builder.left()
                  • AssignmentExpression.Builder.operator()
                  • AssignmentExpression.Builder.right()
                • AssignmentExpression.LEFT
                • AssignmentExpression.OPERATOR
                • AssignmentExpression.RIGHT
                • AssignmentExpression.TYPE_
                • AssignmentExpression.builder()
                • AssignmentExpression.left
                • AssignmentExpression.operator
                • AssignmentExpression.right
                • AssignmentExpression.with_left()
                • AssignmentExpression.with_operator()
                • AssignmentExpression.with_right()
              • AssignmentOperator
                • AssignmentOperator.ADD_ASSIGN
                • AssignmentOperator.AND_ASSIGN
                • AssignmentOperator.ASSIGN
                • AssignmentOperator.BITWISE_AND_ASSIGN
                • AssignmentOperator.BITWISE_OR_ASSIGN
                • AssignmentOperator.BITWISE_XOR_ASSIGN
                • AssignmentOperator.DIVIDE_ASSIGN
                • AssignmentOperator.EXPONENTIATE_ASSIGN
                • AssignmentOperator.LEFT_SHIFT_ASSIGN
                • AssignmentOperator.MODULO_ASSIGN
                • AssignmentOperator.MULTIPLY_ASSIGN
                • AssignmentOperator.NULLISH_ASSIGN
                • AssignmentOperator.OR_ASSIGN
                • AssignmentOperator.RIGHT_SHIFT_ASSIGN
                • AssignmentOperator.SUBTRACT_ASSIGN
                • AssignmentOperator.TYPE_
                • AssignmentOperator.UNSIGNED_RIGHT_SHIFT_ASSIGN
              • AssignmentPattern
                • AssignmentPattern.Builder
                  • AssignmentPattern.Builder.build()
                  • AssignmentPattern.Builder.left()
                  • AssignmentPattern.Builder.right()
                • AssignmentPattern.LEFT
                • AssignmentPattern.RIGHT
                • AssignmentPattern.TYPE_
                • AssignmentPattern.builder()
                • AssignmentPattern.left
                • AssignmentPattern.right
                • AssignmentPattern.with_left()
                • AssignmentPattern.with_right()
              • BinaryExpression
                • BinaryExpression.Builder
                  • BinaryExpression.Builder.build()
                  • BinaryExpression.Builder.left()
                  • BinaryExpression.Builder.operator()
                  • BinaryExpression.Builder.right()
                • BinaryExpression.LEFT
                • BinaryExpression.OPERATOR
                • BinaryExpression.RIGHT
                • BinaryExpression.TYPE_
                • BinaryExpression.builder()
                • BinaryExpression.left
                • BinaryExpression.operator
                • BinaryExpression.right
                • BinaryExpression.with_left()
                • BinaryExpression.with_operator()
                • BinaryExpression.with_right()
              • BinaryOperator
                • BinaryOperator.ADD
                • BinaryOperator.AND
                • BinaryOperator.BITWISE_AND
                • BinaryOperator.BITWISE_OR
                • BinaryOperator.BITWISE_XOR
                • BinaryOperator.DIVIDE
                • BinaryOperator.EQUAL
                • BinaryOperator.EXPONENTIATE
                • BinaryOperator.GREATER_THAN
                • BinaryOperator.GREATER_THAN_OR_EQUAL
                • BinaryOperator.IN
                • BinaryOperator.INSTANCEOF
                • BinaryOperator.LEFT_SHIFT
                • BinaryOperator.LESS_THAN
                • BinaryOperator.LESS_THAN_OR_EQUAL
                • BinaryOperator.MODULO
                • BinaryOperator.MULTIPLY
                • BinaryOperator.NOT_EQUAL
                • BinaryOperator.NULLISH_COALESCING
                • BinaryOperator.OR
                • BinaryOperator.RIGHT_SHIFT
                • BinaryOperator.STRICT_EQUAL
                • BinaryOperator.STRICT_NOT_EQUAL
                • BinaryOperator.SUBTRACT
                • BinaryOperator.TYPE_
                • BinaryOperator.UNSIGNED_RIGHT_SHIFT
              • CallExpression
                • CallExpression.ARGUMENTS
                • CallExpression.Builder
                  • CallExpression.Builder.arguments()
                  • CallExpression.Builder.build()
                  • CallExpression.Builder.callee()
                  • CallExpression.Builder.optional()
                • CallExpression.CALLEE
                • CallExpression.OPTIONAL
                • CallExpression.TYPE_
                • CallExpression.arguments
                • CallExpression.builder()
                • CallExpression.callee
                • CallExpression.optional
                • CallExpression.with_arguments()
                • CallExpression.with_callee()
                • CallExpression.with_optional()
              • CatchClause
                • CatchClause.BODY
                • CatchClause.Builder
                  • CatchClause.Builder.body()
                  • CatchClause.Builder.build()
                  • CatchClause.Builder.param()
                • CatchClause.PARAM
                • CatchClause.TYPE_
                • CatchClause.body
                • CatchClause.builder()
                • CatchClause.param
                • CatchClause.with_body()
                • CatchClause.with_param()
              • ClassDeclaration
                • ClassDeclaration.BODY
                • ClassDeclaration.Builder
                  • ClassDeclaration.Builder.body()
                  • ClassDeclaration.Builder.build()
                  • ClassDeclaration.Builder.id()
                  • ClassDeclaration.Builder.super_class()
                • ClassDeclaration.ID
                • ClassDeclaration.SUPER_CLASS
                • ClassDeclaration.TYPE_
                • ClassDeclaration.body
                • ClassDeclaration.builder()
                • ClassDeclaration.id
                • ClassDeclaration.super_class
                • ClassDeclaration.with_body()
                • ClassDeclaration.with_id()
                • ClassDeclaration.with_super_class()
              • ClassDeclarationWithComments
                • ClassDeclarationWithComments.BODY
                • ClassDeclarationWithComments.Builder
                  • ClassDeclarationWithComments.Builder.body()
                  • ClassDeclarationWithComments.Builder.build()
                  • ClassDeclarationWithComments.Builder.comments()
                • ClassDeclarationWithComments.COMMENTS
                • ClassDeclarationWithComments.TYPE_
                • ClassDeclarationWithComments.body
                • ClassDeclarationWithComments.builder()
                • ClassDeclarationWithComments.comments
                • ClassDeclarationWithComments.with_body()
                • ClassDeclarationWithComments.with_comments()
              • Comment
                • Comment.BLOCK
                • Comment.DOCUMENTATION
                • Comment.LINE
                • Comment.TYPE_
              • CommentBlock
              • CommentDocumentation
              • CommentLine
              • ConditionalExpression
                • ConditionalExpression.ALTERNATE
                • ConditionalExpression.Builder
                  • ConditionalExpression.Builder.alternate()
                  • ConditionalExpression.Builder.build()
                  • ConditionalExpression.Builder.consequent()
                  • ConditionalExpression.Builder.test()
                • ConditionalExpression.CONSEQUENT
                • ConditionalExpression.TEST
                • ConditionalExpression.TYPE_
                • ConditionalExpression.alternate
                • ConditionalExpression.builder()
                • ConditionalExpression.consequent
                • ConditionalExpression.test
                • ConditionalExpression.with_alternate()
                • ConditionalExpression.with_consequent()
                • ConditionalExpression.with_test()
              • DoWhileStatement
                • DoWhileStatement.BODY
                • DoWhileStatement.Builder
                  • DoWhileStatement.Builder.body()
                  • DoWhileStatement.Builder.build()
                  • DoWhileStatement.Builder.test()
                • DoWhileStatement.TEST
                • DoWhileStatement.TYPE_
                • DoWhileStatement.body
                • DoWhileStatement.builder()
                • DoWhileStatement.test
                • DoWhileStatement.with_body()
                • DoWhileStatement.with_test()
              • DocumentationComment
                • DocumentationComment.Builder
                  • DocumentationComment.Builder.build()
                  • DocumentationComment.Builder.description()
                  • DocumentationComment.Builder.tags()
                • DocumentationComment.DESCRIPTION
                • DocumentationComment.TAGS
                • DocumentationComment.TYPE_
                • DocumentationComment.builder()
                • DocumentationComment.description
                • DocumentationComment.tags
                • DocumentationComment.with_description()
                • DocumentationComment.with_tags()
              • DocumentationTag
                • DocumentationTag.Builder
                  • DocumentationTag.Builder.build()
                  • DocumentationTag.Builder.description()
                  • DocumentationTag.Builder.name()
                  • DocumentationTag.Builder.param_name()
                  • DocumentationTag.Builder.type()
                • DocumentationTag.DESCRIPTION
                • DocumentationTag.NAME
                • DocumentationTag.PARAM_NAME
                • DocumentationTag.TYPE
                • DocumentationTag.TYPE_
                • DocumentationTag.builder()
                • DocumentationTag.description
                • DocumentationTag.name
                • DocumentationTag.param_name
                • DocumentationTag.type
                • DocumentationTag.with_description()
                • DocumentationTag.with_name()
                • DocumentationTag.with_param_name()
                • DocumentationTag.with_type()
              • ExportAllDeclaration
                • ExportAllDeclaration.Builder
                  • ExportAllDeclaration.Builder.build()
                  • ExportAllDeclaration.Builder.exported()
                  • ExportAllDeclaration.Builder.source()
                • ExportAllDeclaration.EXPORTED
                • ExportAllDeclaration.SOURCE
                • ExportAllDeclaration.TYPE_
                • ExportAllDeclaration.builder()
                • ExportAllDeclaration.exported
                • ExportAllDeclaration.source
                • ExportAllDeclaration.with_exported()
                • ExportAllDeclaration.with_source()
              • ExportDeclaration
                • ExportDeclaration.ALL
                • ExportDeclaration.DECLARATION
                • ExportDeclaration.DEFAULT
                • ExportDeclaration.NAMED
                • ExportDeclaration.TYPE_
              • ExportDeclarationAll
              • ExportDeclarationDeclaration
              • ExportDeclarationDefault
              • ExportDeclarationNamed
              • ExportSpecifier
                • ExportSpecifier.Builder
                  • ExportSpecifier.Builder.build()
                  • ExportSpecifier.Builder.exported()
                  • ExportSpecifier.Builder.local()
                • ExportSpecifier.EXPORTED
                • ExportSpecifier.LOCAL
                • ExportSpecifier.TYPE_
                • ExportSpecifier.builder()
                • ExportSpecifier.exported
                • ExportSpecifier.local
                • ExportSpecifier.with_exported()
                • ExportSpecifier.with_local()
              • Expression
                • Expression.ARRAY
                • Expression.ARROW
                • Expression.ASSIGNMENT
                • Expression.AS_EXPRESSION
                • Expression.AWAIT
                • Expression.BINARY
                • Expression.CALL
                • Expression.CONDITIONAL
                • Expression.FUNCTION
                • Expression.IDENTIFIER
                • Expression.LITERAL
                • Expression.MEMBER
                • Expression.NEW
                • Expression.OBJECT
                • Expression.PARENTHESIZED
                • Expression.SEQUENCE
                • Expression.SPREAD
                • Expression.THIS
                • Expression.TYPE_
                • Expression.UNARY
                • Expression.YIELD
              • ExpressionArray
              • ExpressionArrow
              • ExpressionAsExpression
              • ExpressionAssignment
              • ExpressionAwait
              • ExpressionBinary
              • ExpressionCall
              • ExpressionConditional
              • ExpressionFunction
              • ExpressionIdentifier
              • ExpressionLiteral
              • ExpressionMember
              • ExpressionNew
              • ExpressionObject
              • ExpressionParenthesized
              • ExpressionSequence
              • ExpressionSpread
              • ExpressionThis
              • ExpressionUnary
              • ExpressionYield
              • ForInLeft
                • ForInLeft.PATTERN
                • ForInLeft.TYPE_
                • ForInLeft.VARIABLE
              • ForInLeftPattern
              • ForInLeftVariable
              • ForInStatement
                • ForInStatement.BODY
                • ForInStatement.Builder
                  • ForInStatement.Builder.body()
                  • ForInStatement.Builder.build()
                  • ForInStatement.Builder.left()
                  • ForInStatement.Builder.right()
                • ForInStatement.LEFT
                • ForInStatement.RIGHT
                • ForInStatement.TYPE_
                • ForInStatement.body
                • ForInStatement.builder()
                • ForInStatement.left
                • ForInStatement.right
                • ForInStatement.with_body()
                • ForInStatement.with_left()
                • ForInStatement.with_right()
              • ForInit
                • ForInit.EXPRESSION
                • ForInit.TYPE_
                • ForInit.VARIABLE
              • ForInitExpression
              • ForInitVariable
              • ForOfStatement
                • ForOfStatement.AWAIT
                • ForOfStatement.BODY
                • ForOfStatement.Builder
                  • ForOfStatement.Builder.await_()
                  • ForOfStatement.Builder.body()
                  • ForOfStatement.Builder.build()
                  • ForOfStatement.Builder.left()
                  • ForOfStatement.Builder.right()
                • ForOfStatement.LEFT
                • ForOfStatement.RIGHT
                • ForOfStatement.TYPE_
                • ForOfStatement.await_
                • ForOfStatement.body
                • ForOfStatement.builder()
                • ForOfStatement.left
                • ForOfStatement.right
                • ForOfStatement.with_await_()
                • ForOfStatement.with_body()
                • ForOfStatement.with_left()
                • ForOfStatement.with_right()
              • ForStatement
                • ForStatement.BODY
                • ForStatement.Builder
                  • ForStatement.Builder.body()
                  • ForStatement.Builder.build()
                  • ForStatement.Builder.init()
                  • ForStatement.Builder.test()
                  • ForStatement.Builder.update()
                • ForStatement.INIT
                • ForStatement.TEST
                • ForStatement.TYPE_
                • ForStatement.UPDATE
                • ForStatement.body
                • ForStatement.builder()
                • ForStatement.init
                • ForStatement.test
                • ForStatement.update
                • ForStatement.with_body()
                • ForStatement.with_init()
                • ForStatement.with_test()
                • ForStatement.with_update()
              • FunctionDeclaration
                • FunctionDeclaration.ASYNC
                • FunctionDeclaration.BODY
                • FunctionDeclaration.Builder
                  • FunctionDeclaration.Builder.async_()
                  • FunctionDeclaration.Builder.body()
                  • FunctionDeclaration.Builder.build()
                  • FunctionDeclaration.Builder.generator()
                  • FunctionDeclaration.Builder.id()
                  • FunctionDeclaration.Builder.params()
                • FunctionDeclaration.GENERATOR
                • FunctionDeclaration.ID
                • FunctionDeclaration.PARAMS
                • FunctionDeclaration.TYPE_
                • FunctionDeclaration.async_
                • FunctionDeclaration.body
                • FunctionDeclaration.builder()
                • FunctionDeclaration.generator
                • FunctionDeclaration.id
                • FunctionDeclaration.params
                • FunctionDeclaration.with_async_()
                • FunctionDeclaration.with_body()
                • FunctionDeclaration.with_generator()
                • FunctionDeclaration.with_id()
                • FunctionDeclaration.with_params()
              • FunctionDeclarationWithComments
                • FunctionDeclarationWithComments.BODY
                • FunctionDeclarationWithComments.Builder
                  • FunctionDeclarationWithComments.Builder.body()
                  • FunctionDeclarationWithComments.Builder.build()
                  • FunctionDeclarationWithComments.Builder.comments()
                • FunctionDeclarationWithComments.COMMENTS
                • FunctionDeclarationWithComments.TYPE_
                • FunctionDeclarationWithComments.body
                • FunctionDeclarationWithComments.builder()
                • FunctionDeclarationWithComments.comments
                • FunctionDeclarationWithComments.with_body()
                • FunctionDeclarationWithComments.with_comments()
              • FunctionExpression
                • FunctionExpression.ASYNC
                • FunctionExpression.BODY
                • FunctionExpression.Builder
                  • FunctionExpression.Builder.async_()
                  • FunctionExpression.Builder.body()
                  • FunctionExpression.Builder.build()
                  • FunctionExpression.Builder.generator()
                  • FunctionExpression.Builder.id()
                  • FunctionExpression.Builder.params()
                • FunctionExpression.GENERATOR
                • FunctionExpression.ID
                • FunctionExpression.PARAMS
                • FunctionExpression.TYPE_
                • FunctionExpression.async_
                • FunctionExpression.body
                • FunctionExpression.builder()
                • FunctionExpression.generator
                • FunctionExpression.id
                • FunctionExpression.params
                • FunctionExpression.with_async_()
                • FunctionExpression.with_body()
                • FunctionExpression.with_generator()
                • FunctionExpression.with_id()
                • FunctionExpression.with_params()
              • FunctionTypeExpression
                • FunctionTypeExpression.Builder
                  • FunctionTypeExpression.Builder.build()
                  • FunctionTypeExpression.Builder.parameters()
                  • FunctionTypeExpression.Builder.return_type()
                  • FunctionTypeExpression.Builder.type_parameters()
                • FunctionTypeExpression.PARAMETERS
                • FunctionTypeExpression.RETURN_TYPE
                • FunctionTypeExpression.TYPE_
                • FunctionTypeExpression.TYPE_PARAMETERS
                • FunctionTypeExpression.builder()
                • FunctionTypeExpression.parameters
                • FunctionTypeExpression.return_type
                • FunctionTypeExpression.type_parameters
                • FunctionTypeExpression.with_parameters()
                • FunctionTypeExpression.with_return_type()
                • FunctionTypeExpression.with_type_parameters()
              • Identifier
                • Identifier.TYPE_
              • IfStatement
                • IfStatement.ALTERNATE
                • IfStatement.Builder
                  • IfStatement.Builder.alternate()
                  • IfStatement.Builder.build()
                  • IfStatement.Builder.consequent()
                  • IfStatement.Builder.test()
                • IfStatement.CONSEQUENT
                • IfStatement.TEST
                • IfStatement.TYPE_
                • IfStatement.alternate
                • IfStatement.builder()
                • IfStatement.consequent
                • IfStatement.test
                • IfStatement.with_alternate()
                • IfStatement.with_consequent()
                • IfStatement.with_test()
              • ImportClause
                • ImportClause.DEFAULT
                • ImportClause.NAMED
                • ImportClause.NAMESPACE
                • ImportClause.TYPE_
              • ImportClauseDefault
              • ImportClauseNamed
              • ImportClauseNamespace
              • ImportDeclaration
                • ImportDeclaration.Builder
                  • ImportDeclaration.Builder.build()
                  • ImportDeclaration.Builder.source()
                  • ImportDeclaration.Builder.specifiers()
                • ImportDeclaration.SOURCE
                • ImportDeclaration.SPECIFIERS
                • ImportDeclaration.TYPE_
                • ImportDeclaration.builder()
                • ImportDeclaration.source
                • ImportDeclaration.specifiers
                • ImportDeclaration.with_source()
                • ImportDeclaration.with_specifiers()
              • ImportDefaultSpecifier
                • ImportDefaultSpecifier.TYPE_
              • ImportNamespaceSpecifier
                • ImportNamespaceSpecifier.TYPE_
              • ImportSpecifier
                • ImportSpecifier.Builder
                  • ImportSpecifier.Builder.build()
                  • ImportSpecifier.Builder.imported()
                  • ImportSpecifier.Builder.local()
                • ImportSpecifier.IMPORTED
                • ImportSpecifier.LOCAL
                • ImportSpecifier.TYPE_
                • ImportSpecifier.builder()
                • ImportSpecifier.imported
                • ImportSpecifier.local
                • ImportSpecifier.with_imported()
                • ImportSpecifier.with_local()
              • InterfaceDeclaration
                • InterfaceDeclaration.Builder
                  • InterfaceDeclaration.Builder.build()
                  • InterfaceDeclaration.Builder.extends()
                  • InterfaceDeclaration.Builder.members()
                  • InterfaceDeclaration.Builder.name()
                  • InterfaceDeclaration.Builder.type_parameters()
                • InterfaceDeclaration.EXTENDS
                • InterfaceDeclaration.MEMBERS
                • InterfaceDeclaration.NAME
                • InterfaceDeclaration.TYPE_
                • InterfaceDeclaration.TYPE_PARAMETERS
                • InterfaceDeclaration.builder()
                • InterfaceDeclaration.extends
                • InterfaceDeclaration.members
                • InterfaceDeclaration.name
                • InterfaceDeclaration.type_parameters
                • InterfaceDeclaration.with_extends()
                • InterfaceDeclaration.with_members()
                • InterfaceDeclaration.with_name()
                • InterfaceDeclaration.with_type_parameters()
              • LabeledStatement
                • LabeledStatement.BODY
                • LabeledStatement.Builder
                  • LabeledStatement.Builder.body()
                  • LabeledStatement.Builder.build()
                  • LabeledStatement.Builder.label()
                • LabeledStatement.LABEL
                • LabeledStatement.TYPE_
                • LabeledStatement.body
                • LabeledStatement.builder()
                • LabeledStatement.label
                • LabeledStatement.with_body()
                • LabeledStatement.with_label()
              • Literal
                • Literal.BIG_INT
                • Literal.BOOLEAN
                • Literal.NULL
                • Literal.NUMBER
                • Literal.STRING
                • Literal.TEMPLATE
                • Literal.TYPE_
                • Literal.UNDEFINED
              • LiteralBigInt
              • LiteralBoolean
              • LiteralNull
              • LiteralNumber
              • LiteralString
              • LiteralTemplate
              • LiteralUndefined
              • MemberExpression
                • MemberExpression.Builder
                  • MemberExpression.Builder.build()
                  • MemberExpression.Builder.computed()
                  • MemberExpression.Builder.object()
                  • MemberExpression.Builder.optional()
                  • MemberExpression.Builder.property()
                • MemberExpression.COMPUTED
                • MemberExpression.OBJECT
                • MemberExpression.OPTIONAL
                • MemberExpression.PROPERTY
                • MemberExpression.TYPE_
                • MemberExpression.builder()
                • MemberExpression.computed
                • MemberExpression.object
                • MemberExpression.optional
                • MemberExpression.property
                • MemberExpression.with_computed()
                • MemberExpression.with_object()
                • MemberExpression.with_optional()
                • MemberExpression.with_property()
              • MethodDefinition
                • MethodDefinition.Builder
                  • MethodDefinition.Builder.build()
                  • MethodDefinition.Builder.computed()
                  • MethodDefinition.Builder.key()
                  • MethodDefinition.Builder.kind()
                  • MethodDefinition.Builder.static()
                  • MethodDefinition.Builder.value()
                • MethodDefinition.COMPUTED
                • MethodDefinition.KEY
                • MethodDefinition.KIND
                • MethodDefinition.STATIC
                • MethodDefinition.TYPE_
                • MethodDefinition.VALUE
                • MethodDefinition.builder()
                • MethodDefinition.computed
                • MethodDefinition.key
                • MethodDefinition.kind
                • MethodDefinition.static
                • MethodDefinition.value
                • MethodDefinition.with_computed()
                • MethodDefinition.with_key()
                • MethodDefinition.with_kind()
                • MethodDefinition.with_static()
                • MethodDefinition.with_value()
              • MethodKind
                • MethodKind.CONSTRUCTOR
                • MethodKind.GET
                • MethodKind.METHOD
                • MethodKind.SET
                • MethodKind.TYPE_
              • ModuleItem
                • ModuleItem.EXPORT
                • ModuleItem.IMPORT
                • ModuleItem.INTERFACE
                • ModuleItem.STATEMENT
                • ModuleItem.TYPE_
                • ModuleItem.TYPE_ALIAS
              • ModuleItemExport
              • ModuleItemImport
              • ModuleItemInterface
              • ModuleItemStatement
              • ModuleItemTypeAlias
              • ModuleItemWithComments
                • ModuleItemWithComments.BODY
                • ModuleItemWithComments.Builder
                  • ModuleItemWithComments.Builder.body()
                  • ModuleItemWithComments.Builder.build()
                  • ModuleItemWithComments.Builder.comments()
                • ModuleItemWithComments.COMMENTS
                • ModuleItemWithComments.TYPE_
                • ModuleItemWithComments.body
                • ModuleItemWithComments.builder()
                • ModuleItemWithComments.comments
                • ModuleItemWithComments.with_body()
                • ModuleItemWithComments.with_comments()
              • NamedExport
                • NamedExport.Builder
                  • NamedExport.Builder.build()
                  • NamedExport.Builder.source()
                  • NamedExport.Builder.specifiers()
                • NamedExport.SOURCE
                • NamedExport.SPECIFIERS
                • NamedExport.TYPE_
                • NamedExport.builder()
                • NamedExport.source
                • NamedExport.specifiers
                • NamedExport.with_source()
                • NamedExport.with_specifiers()
              • NumericLiteral
                • NumericLiteral.FLOAT
                • NumericLiteral.INTEGER
                • NumericLiteral.TYPE_
              • NumericLiteralFloat
              • NumericLiteralInteger
              • ObjectPattern
                • ObjectPattern.Builder
                  • ObjectPattern.Builder.build()
                  • ObjectPattern.Builder.properties()
                • ObjectPattern.PROPERTIES
                • ObjectPattern.TYPE_
                • ObjectPattern.builder()
                • ObjectPattern.properties
                • ObjectPattern.with_properties()
              • ObjectPatternProperty
                • ObjectPatternProperty.PROPERTY
                • ObjectPatternProperty.REST
                • ObjectPatternProperty.TYPE_
              • ObjectPatternPropertyProperty
              • ObjectPatternPropertyRest
              • ParameterizedTypeExpression
                • ParameterizedTypeExpression.ARGUMENTS
                • ParameterizedTypeExpression.BASE
                • ParameterizedTypeExpression.Builder
                  • ParameterizedTypeExpression.Builder.arguments()
                  • ParameterizedTypeExpression.Builder.base()
                  • ParameterizedTypeExpression.Builder.build()
                • ParameterizedTypeExpression.TYPE_
                • ParameterizedTypeExpression.arguments
                • ParameterizedTypeExpression.base
                • ParameterizedTypeExpression.builder()
                • ParameterizedTypeExpression.with_arguments()
                • ParameterizedTypeExpression.with_base()
              • Pattern
                • Pattern.ARRAY
                • Pattern.ASSIGNMENT
                • Pattern.IDENTIFIER
                • Pattern.OBJECT
                • Pattern.REST
                • Pattern.TYPED
                • Pattern.TYPE_
              • PatternArray
              • PatternAssignment
              • PatternIdentifier
              • PatternObject
              • PatternRest
              • PatternTyped
              • Program
                • Program.BODY
                • Program.Builder
                  • Program.Builder.body()
                  • Program.Builder.build()
                  • Program.Builder.source_type()
                • Program.SOURCE_TYPE
                • Program.TYPE_
                • Program.body
                • Program.builder()
                • Program.source_type
                • Program.with_body()
                • Program.with_source_type()
              • Property
                • Property.Builder
                  • Property.Builder.build()
                  • Property.Builder.computed()
                  • Property.Builder.key()
                  • Property.Builder.kind()
                  • Property.Builder.shorthand()
                  • Property.Builder.value()
                • Property.COMPUTED
                • Property.KEY
                • Property.KIND
                • Property.SHORTHAND
                • Property.TYPE_
                • Property.VALUE
                • Property.builder()
                • Property.computed
                • Property.key
                • Property.kind
                • Property.shorthand
                • Property.value
                • Property.with_computed()
                • Property.with_key()
                • Property.with_kind()
                • Property.with_shorthand()
                • Property.with_value()
              • PropertyKind
                • PropertyKind.GET
                • PropertyKind.INIT
                • PropertyKind.SET
                • PropertyKind.TYPE_
              • PropertySignature
                • PropertySignature.Builder
                  • PropertySignature.Builder.build()
                  • PropertySignature.Builder.comments()
                  • PropertySignature.Builder.name()
                  • PropertySignature.Builder.optional()
                  • PropertySignature.Builder.readonly()
                  • PropertySignature.Builder.type()
                • PropertySignature.COMMENTS
                • PropertySignature.NAME
                • PropertySignature.OPTIONAL
                • PropertySignature.READONLY
                • PropertySignature.TYPE
                • PropertySignature.TYPE_
                • PropertySignature.builder()
                • PropertySignature.comments
                • PropertySignature.name
                • PropertySignature.optional
                • PropertySignature.readonly
                • PropertySignature.type
                • PropertySignature.with_comments()
                • PropertySignature.with_name()
                • PropertySignature.with_optional()
                • PropertySignature.with_readonly()
                • PropertySignature.with_type()
              • RestElement
                • RestElement.TYPE_
              • SourceType
                • SourceType.MODULE
                • SourceType.SCRIPT
                • SourceType.TYPE_
              • SpreadElement
                • SpreadElement.TYPE_
              • Statement
                • Statement.BLOCK
                • Statement.BREAK
                • Statement.CLASS_DECLARATION
                • Statement.CONTINUE
                • Statement.DEBUGGER
                • Statement.DO_WHILE
                • Statement.EMPTY
                • Statement.EXPRESSION
                • Statement.FOR
                • Statement.FOR_IN
                • Statement.FOR_OF
                • Statement.FUNCTION_DECLARATION
                • Statement.IF
                • Statement.LABELED
                • Statement.RETURN
                • Statement.SWITCH
                • Statement.THROW
                • Statement.TRY
                • Statement.TYPE_
                • Statement.VARIABLE_DECLARATION
                • Statement.WHILE
              • StatementBlock
              • StatementBreak
              • StatementClassDeclaration
              • StatementContinue
              • StatementDebugger
              • StatementDoWhile
              • StatementEmpty
              • StatementExpression
              • StatementFor
              • StatementForIn
              • StatementForOf
              • StatementFunctionDeclaration
              • StatementIf
              • StatementLabeled
              • StatementReturn
              • StatementSwitch
              • StatementThrow
              • StatementTry
              • StatementVariableDeclaration
              • StatementWhile
              • StatementWithComments
                • StatementWithComments.BODY
                • StatementWithComments.Builder
                  • StatementWithComments.Builder.body()
                  • StatementWithComments.Builder.build()
                  • StatementWithComments.Builder.comments()
                • StatementWithComments.COMMENTS
                • StatementWithComments.TYPE_
                • StatementWithComments.body
                • StatementWithComments.builder()
                • StatementWithComments.comments
                • StatementWithComments.with_body()
                • StatementWithComments.with_comments()
              • StringLiteral
                • StringLiteral.Builder
                  • StringLiteral.Builder.build()
                  • StringLiteral.Builder.single_quote()
                  • StringLiteral.Builder.value()
                • StringLiteral.SINGLE_QUOTE
                • StringLiteral.TYPE_
                • StringLiteral.VALUE
                • StringLiteral.builder()
                • StringLiteral.single_quote
                • StringLiteral.value
                • StringLiteral.with_single_quote()
                • StringLiteral.with_value()
              • SwitchCase
                • SwitchCase.Builder
                  • SwitchCase.Builder.build()
                  • SwitchCase.Builder.consequent()
                  • SwitchCase.Builder.test()
                • SwitchCase.CONSEQUENT
                • SwitchCase.TEST
                • SwitchCase.TYPE_
                • SwitchCase.builder()
                • SwitchCase.consequent
                • SwitchCase.test
                • SwitchCase.with_consequent()
                • SwitchCase.with_test()
              • SwitchStatement
                • SwitchStatement.Builder
                  • SwitchStatement.Builder.build()
                  • SwitchStatement.Builder.cases()
                  • SwitchStatement.Builder.discriminant()
                • SwitchStatement.CASES
                • SwitchStatement.DISCRIMINANT
                • SwitchStatement.TYPE_
                • SwitchStatement.builder()
                • SwitchStatement.cases
                • SwitchStatement.discriminant
                • SwitchStatement.with_cases()
                • SwitchStatement.with_discriminant()
              • TemplateElement
                • TemplateElement.Builder
                  • TemplateElement.Builder.build()
                  • TemplateElement.Builder.tail()
                  • TemplateElement.Builder.value()
                • TemplateElement.TAIL
                • TemplateElement.TYPE_
                • TemplateElement.VALUE
                • TemplateElement.builder()
                • TemplateElement.tail
                • TemplateElement.value
                • TemplateElement.with_tail()
                • TemplateElement.with_value()
              • TemplateLiteral
                • TemplateLiteral.Builder
                  • TemplateLiteral.Builder.build()
                  • TemplateLiteral.Builder.expressions()
                  • TemplateLiteral.Builder.quasis()
                • TemplateLiteral.EXPRESSIONS
                • TemplateLiteral.QUASIS
                • TemplateLiteral.TYPE_
                • TemplateLiteral.builder()
                • TemplateLiteral.expressions
                • TemplateLiteral.quasis
                • TemplateLiteral.with_expressions()
                • TemplateLiteral.with_quasis()
              • ThrowStatement
                • ThrowStatement.TYPE_
              • TryStatement
                • TryStatement.BLOCK
                • TryStatement.Builder
                  • TryStatement.Builder.block()
                  • TryStatement.Builder.build()
                  • TryStatement.Builder.finalizer()
                  • TryStatement.Builder.handler()
                • TryStatement.FINALIZER
                • TryStatement.HANDLER
                • TryStatement.TYPE_
                • TryStatement.block
                • TryStatement.builder()
                • TryStatement.finalizer
                • TryStatement.handler
                • TryStatement.with_block()
                • TryStatement.with_finalizer()
                • TryStatement.with_handler()
              • TypeAliasDeclaration
                • TypeAliasDeclaration.Builder
                  • TypeAliasDeclaration.Builder.build()
                  • TypeAliasDeclaration.Builder.name()
                  • TypeAliasDeclaration.Builder.type()
                  • TypeAliasDeclaration.Builder.type_parameters()
                • TypeAliasDeclaration.NAME
                • TypeAliasDeclaration.TYPE
                • TypeAliasDeclaration.TYPE_
                • TypeAliasDeclaration.TYPE_PARAMETERS
                • TypeAliasDeclaration.builder()
                • TypeAliasDeclaration.name
                • TypeAliasDeclaration.type
                • TypeAliasDeclaration.type_parameters
                • TypeAliasDeclaration.with_name()
                • TypeAliasDeclaration.with_type()
                • TypeAliasDeclaration.with_type_parameters()
              • TypeAnnotation
                • TypeAnnotation.TYPE_
              • TypeExpression
                • TypeExpression.ANY
                • TypeExpression.ARRAY
                • TypeExpression.FUNCTION
                • TypeExpression.IDENTIFIER
                • TypeExpression.INTERSECTION
                • TypeExpression.LITERAL
                • TypeExpression.NEVER
                • TypeExpression.OBJECT
                • TypeExpression.OPTIONAL
                • TypeExpression.PARAMETERIZED
                • TypeExpression.READONLY
                • TypeExpression.TUPLE
                • TypeExpression.TYPE_
                • TypeExpression.UNION
                • TypeExpression.UNKNOWN
                • TypeExpression.VOID
              • TypeExpressionAny
              • TypeExpressionArray
              • TypeExpressionFunction
              • TypeExpressionIdentifier
              • TypeExpressionIntersection
              • TypeExpressionLiteral
              • TypeExpressionNever
              • TypeExpressionObject
              • TypeExpressionOptional
              • TypeExpressionParameterized
              • TypeExpressionReadonly
              • TypeExpressionTuple
              • TypeExpressionUnion
              • TypeExpressionUnknown
              • TypeExpressionVoid
              • TypeParameter
                • TypeParameter.Builder
                  • TypeParameter.Builder.build()
                  • TypeParameter.Builder.constraint()
                  • TypeParameter.Builder.default()
                  • TypeParameter.Builder.name()
                • TypeParameter.CONSTRAINT
                • TypeParameter.DEFAULT
                • TypeParameter.NAME
                • TypeParameter.TYPE_
                • TypeParameter.builder()
                • TypeParameter.constraint
                • TypeParameter.default
                • TypeParameter.name
                • TypeParameter.with_constraint()
                • TypeParameter.with_default()
                • TypeParameter.with_name()
              • TypedPattern
                • TypedPattern.Builder
                  • TypedPattern.Builder.build()
                  • TypedPattern.Builder.pattern()
                  • TypedPattern.Builder.type()
                • TypedPattern.PATTERN
                • TypedPattern.TYPE
                • TypedPattern.TYPE_
                • TypedPattern.builder()
                • TypedPattern.pattern
                • TypedPattern.type
                • TypedPattern.with_pattern()
                • TypedPattern.with_type()
              • UnaryExpression
                • UnaryExpression.ARGUMENT
                • UnaryExpression.Builder
                  • UnaryExpression.Builder.argument()
                  • UnaryExpression.Builder.build()
                  • UnaryExpression.Builder.operator()
                  • UnaryExpression.Builder.prefix()
                • UnaryExpression.OPERATOR
                • UnaryExpression.PREFIX
                • UnaryExpression.TYPE_
                • UnaryExpression.argument
                • UnaryExpression.builder()
                • UnaryExpression.operator
                • UnaryExpression.prefix
                • UnaryExpression.with_argument()
                • UnaryExpression.with_operator()
                • UnaryExpression.with_prefix()
              • UnaryOperator
                • UnaryOperator.BITWISE_NOT
                • UnaryOperator.DECREMENT
                • UnaryOperator.DELETE
                • UnaryOperator.INCREMENT
                • UnaryOperator.NEGATE
                • UnaryOperator.NOT
                • UnaryOperator.PLUS
                • UnaryOperator.TYPEOF
                • UnaryOperator.TYPE_
                • UnaryOperator.VOID
              • VariableDeclaration
                • VariableDeclaration.Builder
                  • VariableDeclaration.Builder.build()
                  • VariableDeclaration.Builder.declarations()
                  • VariableDeclaration.Builder.kind()
                • VariableDeclaration.DECLARATIONS
                • VariableDeclaration.KIND
                • VariableDeclaration.TYPE_
                • VariableDeclaration.builder()
                • VariableDeclaration.declarations
                • VariableDeclaration.kind
                • VariableDeclaration.with_declarations()
                • VariableDeclaration.with_kind()
              • VariableDeclarator
                • VariableDeclarator.Builder
                  • VariableDeclarator.Builder.build()
                  • VariableDeclarator.Builder.id()
                  • VariableDeclarator.Builder.init()
                • VariableDeclarator.ID
                • VariableDeclarator.INIT
                • VariableDeclarator.TYPE_
                • VariableDeclarator.builder()
                • VariableDeclarator.id
                • VariableDeclarator.init
                • VariableDeclarator.with_id()
                • VariableDeclarator.with_init()
              • VariableKind
                • VariableKind.CONST
                • VariableKind.LET
                • VariableKind.TYPE_
                • VariableKind.VAR
              • WhileStatement
                • WhileStatement.BODY
                • WhileStatement.Builder
                  • WhileStatement.Builder.body()
                  • WhileStatement.Builder.build()
                  • WhileStatement.Builder.test()
                • WhileStatement.TEST
                • WhileStatement.TYPE_
                • WhileStatement.body
                • WhileStatement.builder()
                • WhileStatement.test
                • WhileStatement.with_body()
                • WhileStatement.with_test()
hydra-typescript
  • Search


© Copyright 2026, Hydra.

Built with Sphinx using a theme provided by Read the Docs.