# typed: strict
# ----------------------------------------------------------------------------
#
#  Welcome to Baml! To use this generated code, please run the following:
#
#  $ gem install baml
#
# ----------------------------------------------------------------------------

# This file was generated by BAML: please do not edit it. Instead, edit the
# BAML files and re-generate this code using: baml-cli generate
# baml-cli is available with the baml package.
# gem install baml
require "sorbet-runtime"
require "baml"

module BamlClient

  extend T::Sig


  @baml_sync_client = T.let(BamlSyncClient.new(BamlClient::Internal::DoNotUseDirectlyCallManager.new(BamlCallOptions.from_hash({}))), BamlSyncClient)

  sig {returns(BamlSyncClient)}
  def self.b
     @baml_sync_client
  end

  class BamlSyncClient
      extend T::Sig


      sig {params(options: BamlClient::Internal::DoNotUseDirectlyCallManager).void}
      def initialize(options)
          @options = options
      end

      sig {params(collector: T.nilable(T.any(Baml::Collector, T::Array[Baml::Collector])), tb: T.nilable(Baml::TypeBuilder), client_registry: T.nilable(Baml::ClientRegistry), env_vars: T.nilable(T::Hash[Symbol, String]), tags: T.nilable(T::Hash[String, String])).returns(BamlSyncClient)}
      def with_options(collector: nil, tb: nil, client_registry: nil, env_vars: nil, tags: nil)
          BamlSyncClient.new(@options.merge_options(BamlCallOptions.from_hash({
              collector: collector,
              tb: tb,
              client_registry: client_registry,
              env_vars: env_vars,
              tags: tags,
          })))
      end

      sig {params(
          varargs: T.untyped,
          recipe: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::Recipe)}
      def AaaSamOutputFormat(
          *varargs,
          recipe:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AaaSamOutputFormat may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "AaaSamOutputFormat", args: {
              recipe: recipe,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::Recipe)
      end
      sig {params(
          varargs: T.untyped,
          data: BamlClient::Types::LinkedListAliasNode,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::LinkedListAliasNode)}
      def AliasThatPointsToRecursiveType(
          *varargs,
          data:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AliasThatPointsToRecursiveType may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "AliasThatPointsToRecursiveType", args: {
              data: data,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::LinkedListAliasNode)
      end
      sig {params(
          varargs: T.untyped,
          money: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::Checked[Integer])}
      def AliasWithMultipleAttrs(
          *varargs,
          money:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AliasWithMultipleAttrs may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "AliasWithMultipleAttrs", args: {
              money: money,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::Checked[Integer])
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::InputClass,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def AliasedInputClass(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AliasedInputClass may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "AliasedInputClass", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::InputClass,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def AliasedInputClass2(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AliasedInputClass2 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "AliasedInputClass2", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::InputClassNested,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def AliasedInputClassNested(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AliasedInputClassNested may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "AliasedInputClassNested", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::AliasedEnum,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def AliasedInputEnum(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AliasedInputEnum may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "AliasedInputEnum", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: T::Array[BamlClient::Types::AliasedEnum],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def AliasedInputList(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AliasedInputList may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "AliasedInputList", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          optionals: BamlClient::Types::OptionalListAndMap,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::OptionalListAndMap)}
      def AllowedOptionals(
          *varargs,
          optionals:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AllowedOptionals may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "AllowedOptionals", args: {
              optionals: optionals,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::OptionalListAndMap)
      end
      sig {params(
          varargs: T.untyped,
          a: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Integer)}
      def AssertFn(
          *varargs,
          a:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AssertFn may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "AssertFn", args: {
              a: a,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(Integer)
      end
      sig {params(
          varargs: T.untyped,
          aud: Baml::Audio,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def AudioInput(
          *varargs,
          aud:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AudioInput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "AudioInput", args: {
              aud: aud,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          aud: Baml::Audio,prompt: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def AudioInputOpenai(
          *varargs,
          aud:,prompt:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AudioInputOpenai may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "AudioInputOpenai", args: {
              aud: aud,prompt: prompt,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: T::Array[Integer],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::LinkedList)}
      def BuildLinkedList(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("BuildLinkedList may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "BuildLinkedList", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::LinkedList)
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::BinaryNode,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::Tree)}
      def BuildTree(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("BuildTree may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "BuildTree", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::Tree)
      end
      sig {params(
          varargs: T.untyped,
          word: String,target: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Boolean)}
      def CheckWordEquality(
          *varargs,
          word:,target:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("CheckWordEquality may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "CheckWordEquality", args: {
              word: word,target: target,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Boolean)
      end
      sig {params(
          varargs: T.untyped,
          query: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Array[T.any(BamlClient::Types::AddTodoItem, BamlClient::Types::TodoMessageToUser)])}
      def ChooseTodoTools(
          *varargs,
          query:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ChooseTodoTools may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ChooseTodoTools", args: {
              query: query,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Array[T.any(BamlClient::Types::AddTodoItem, BamlClient::Types::TodoMessageToUser)])
      end
      sig {params(
          varargs: T.untyped,
          cls: BamlClient::Types::ClassToRecAlias,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::ClassToRecAlias)}
      def ClassThatPointsToRecursiveClassThroughAlias(
          *varargs,
          cls:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ClassThatPointsToRecursiveClassThroughAlias may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ClassThatPointsToRecursiveClassThroughAlias", args: {
              cls: cls,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::ClassToRecAlias)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T.any(BamlClient::Types::DynEnumTwo, String))}
      def ClassifyDynEnumTwo(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ClassifyDynEnumTwo may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ClassifyDynEnumTwo", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T.any(BamlClient::Types::DynEnumTwo, String))
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T.any(BamlClient::Types::DynEnumOne, String))}
      def ClassifyDynamicStatus(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ClassifyDynamicStatus may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ClassifyDynamicStatus", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T.any(BamlClient::Types::DynEnumOne, String))
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::Category)}
      def ClassifyMessage(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ClassifyMessage may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ClassifyMessage", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::Category)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::Category)}
      def ClassifyMessage2(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ClassifyMessage2 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ClassifyMessage2", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::Category)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::Category)}
      def ClassifyMessage3(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ClassifyMessage3 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ClassifyMessage3", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::Category)
      end
      sig {params(
          varargs: T.untyped,
          prefix: String,suffix: String,language: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def Completion(
          *varargs,
          prefix:,suffix:,language:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("Completion may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "Completion", args: {
              prefix: prefix,suffix: suffix,language: language,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T.any(BamlClient::Types::BookOrder, BamlClient::Types::FlightConfirmation, BamlClient::Types::GroceryReceipt))}
      def CustomTask(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("CustomTask may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "CustomTask", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T.any(BamlClient::Types::BookOrder, BamlClient::Types::FlightConfirmation, BamlClient::Types::GroceryReceipt))
      end
      sig {params(
          varargs: T.untyped,
          audio: Baml::Audio,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def DescribeAudio(
          *varargs,
          audio:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DescribeAudio may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "DescribeAudio", args: {
              audio: audio,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          audio: Baml::Audio,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def DescribeAudio2(
          *varargs,
          audio:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DescribeAudio2 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "DescribeAudio2", args: {
              audio: audio,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          img: Baml::Image,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def DescribeImage(
          *varargs,
          img:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DescribeImage may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "DescribeImage", args: {
              img: img,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          classWithImage: BamlClient::Types::ClassWithImage,img2: Baml::Image,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def DescribeImage2(
          *varargs,
          classWithImage:,img2:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DescribeImage2 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "DescribeImage2", args: {
              classWithImage: classWithImage,img2: img2,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          classWithImage: BamlClient::Types::ClassWithImage,img2: Baml::Image,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def DescribeImage3(
          *varargs,
          classWithImage:,img2:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DescribeImage3 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "DescribeImage3", args: {
              classWithImage: classWithImage,img2: img2,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          classWithImage: BamlClient::Types::ClassWithImage,img2: Baml::Image,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def DescribeImage4(
          *varargs,
          classWithImage:,img2:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DescribeImage4 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "DescribeImage4", args: {
              classWithImage: classWithImage,img2: img2,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          img: Baml::Image,client_sector: String,client_name: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def DescribeMedia1599(
          *varargs,
          img:,client_sector:,client_name:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DescribeMedia1599 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "DescribeMedia1599", args: {
              img: img,client_sector: client_sector,client_name: client_name,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T.any(BamlClient::Types::OriginalA, BamlClient::Types::OriginalB))}
      def DifferentiateUnions(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DifferentiateUnions may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "DifferentiateUnions", args: {

          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T.any(BamlClient::Types::OriginalA, BamlClient::Types::OriginalB))
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::DummyOutput)}
      def DummyOutputFunction(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DummyOutputFunction may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "DummyOutputFunction", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::DummyOutput)
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::DynamicClassOne,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::DynamicClassTwo)}
      def DynamicFunc(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DynamicFunc may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "DynamicFunc", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::DynamicClassTwo)
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::DynInputOutput,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::DynInputOutput)}
      def DynamicInputOutput(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DynamicInputOutput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "DynamicInputOutput", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::DynInputOutput)
      end
      sig {params(
          varargs: T.untyped,
          input: T::Array[BamlClient::Types::DynInputOutput],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Array[BamlClient::Types::DynInputOutput])}
      def DynamicListInputOutput(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DynamicListInputOutput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "DynamicListInputOutput", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Array[BamlClient::Types::DynInputOutput])
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def ExpectFailure(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExpectFailure may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ExpectFailure", args: {

          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          document: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::ContactInfo)}
      def ExtractContactInfo(
          *varargs,
          document:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExtractContactInfo may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ExtractContactInfo", args: {
              document: document,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::ContactInfo)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Array[T.any(BamlClient::Types::DynEnumTwo, String)])}
      def ExtractDynamicCategories(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExtractDynamicCategories may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ExtractDynamicCategories", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Array[T.any(BamlClient::Types::DynEnumTwo, String)])
      end
      sig {params(
          varargs: T.untyped,
          text: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::DynamicSchema)}
      def ExtractEntities(
          *varargs,
          text:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExtractEntities may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ExtractEntities", args: {
              text: text,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::DynamicSchema)
      end
      sig {params(
          varargs: T.untyped,
          text: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Array[T.any(BamlClient::Types::Hobby, String)])}
      def ExtractHobby(
          *varargs,
          text:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExtractHobby may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ExtractHobby", args: {
              text: text,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Array[T.any(BamlClient::Types::Hobby, String)])
      end
      sig {params(
          varargs: T.untyped,
          text: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def ExtractName(
          *varargs,
          text:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExtractName may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ExtractName", args: {
              text: text,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Array[String])}
      def ExtractNames(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExtractNames may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ExtractNames", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Array[String])
      end
      sig {params(
          varargs: T.untyped,
          text: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Array[BamlClient::Types::Person])}
      def ExtractPeople(
          *varargs,
          text:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExtractPeople may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ExtractPeople", args: {
              text: text,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Array[BamlClient::Types::Person])
      end
      sig {params(
          varargs: T.untyped,
          email: String,reason: T.any(String, String),
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::ReceiptInfo)}
      def ExtractReceiptInfo(
          *varargs,
          email:,reason:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExtractReceiptInfo may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ExtractReceiptInfo", args: {
              email: email,reason: reason,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::ReceiptInfo)
      end
      sig {params(
          varargs: T.untyped,
          resume: String,img: T.nilable(Baml::Image),
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::Resume)}
      def ExtractResume(
          *varargs,
          resume:,img:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExtractResume may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ExtractResume", args: {
              resume: resume,img: img,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::Resume)
      end
      sig {params(
          varargs: T.untyped,
          resume: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::Resume)}
      def ExtractResume2(
          *varargs,
          resume:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExtractResume2 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ExtractResume2", args: {
              resume: resume,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::Resume)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def FnAlwaysFails(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnAlwaysFails may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnAlwaysFails", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T.nilable(BamlClient::Types::ClassOptionalOutput))}
      def FnClassOptionalOutput(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnClassOptionalOutput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnClassOptionalOutput", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T.nilable(BamlClient::Types::ClassOptionalOutput))
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T.nilable(BamlClient::Types::ClassOptionalOutput2))}
      def FnClassOptionalOutput2(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnClassOptionalOutput2 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnClassOptionalOutput2", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T.nilable(BamlClient::Types::ClassOptionalOutput2))
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Array[BamlClient::Types::EnumOutput])}
      def FnEnumListOutput(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnEnumListOutput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnEnumListOutput", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Array[BamlClient::Types::EnumOutput])
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::EnumOutput)}
      def FnEnumOutput(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnEnumOutput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnEnumOutput", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::EnumOutput)
      end
      sig {params(
          varargs: T.untyped,
          retries: Integer,delay_ms: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def FnFailRetryConstantDelay(
          *varargs,
          retries:,delay_ms:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnFailRetryConstantDelay may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnFailRetryConstantDelay", args: {
              retries: retries,delay_ms: delay_ms,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          retries: Integer,initial_delay_ms: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def FnFailRetryExponentialDelay(
          *varargs,
          retries:,initial_delay_ms:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnFailRetryExponentialDelay may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnFailRetryExponentialDelay", args: {
              retries: retries,initial_delay_ms: initial_delay_ms,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def FnFallbackAlwaysFails(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnFallbackAlwaysFails may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnFallbackAlwaysFails", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::LiteralClassHello,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::LiteralClassHello)}
      def FnLiteralClassInputOutput(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnLiteralClassInputOutput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnLiteralClassInputOutput", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::LiteralClassHello)
      end
      sig {params(
          varargs: T.untyped,
          input: T.any(BamlClient::Types::LiteralClassOne, BamlClient::Types::LiteralClassTwo),
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T.any(BamlClient::Types::LiteralClassOne, BamlClient::Types::LiteralClassTwo))}
      def FnLiteralUnionClassInputOutput(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnLiteralUnionClassInputOutput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnLiteralUnionClassInputOutput", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T.any(BamlClient::Types::LiteralClassOne, BamlClient::Types::LiteralClassTwo))
      end
      sig {params(
          varargs: T.untyped,
          myString: T.nilable(String),
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def FnNamedArgsSingleStringOptional(
          *varargs,
          myString:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnNamedArgsSingleStringOptional may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnNamedArgsSingleStringOptional", args: {
              myString: myString,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Boolean)}
      def FnOutputBool(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnOutputBool may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnOutputBool", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Boolean)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::TestOutputClass)}
      def FnOutputClass(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnOutputClass may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnOutputClass", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::TestOutputClass)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Array[BamlClient::Types::TestOutputClass])}
      def FnOutputClassList(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnOutputClassList may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnOutputClassList", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Array[BamlClient::Types::TestOutputClass])
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::TestClassNested)}
      def FnOutputClassNested(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnOutputClassNested may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnOutputClassNested", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::TestClassNested)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::TestClassWithEnum)}
      def FnOutputClassWithEnum(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnOutputClassWithEnum may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnOutputClassWithEnum", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::TestClassWithEnum)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Integer)}
      def FnOutputInt(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnOutputInt may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnOutputInt", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(Integer)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Boolean)}
      def FnOutputLiteralBool(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnOutputLiteralBool may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnOutputLiteralBool", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Boolean)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Integer)}
      def FnOutputLiteralInt(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnOutputLiteralInt may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnOutputLiteralInt", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(Integer)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def FnOutputLiteralString(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnOutputLiteralString may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnOutputLiteralString", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Array[String])}
      def FnOutputStringList(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnOutputStringList may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnOutputStringList", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Array[String])
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::TestEnum)}
      def FnTestAliasedEnumOutput(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnTestAliasedEnumOutput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnTestAliasedEnumOutput", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::TestEnum)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::TestClassAlias)}
      def FnTestClassAlias(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnTestClassAlias may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnTestClassAlias", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::TestClassAlias)
      end
      sig {params(
          varargs: T.untyped,
          myArg: BamlClient::Types::NamedArgsSingleEnum,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def FnTestNamedArgsSingleEnum(
          *varargs,
          myArg:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnTestNamedArgsSingleEnum may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "FnTestNamedArgsSingleEnum", args: {
              myArg: myArg,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          text: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::RaysData)}
      def GetDataType(
          *varargs,
          text:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("GetDataType may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "GetDataType", args: {
              text: text,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::RaysData)
      end
      sig {params(
          varargs: T.untyped,
          email: BamlClient::Types::Email,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::OrderInfo)}
      def GetOrderInfo(
          *varargs,
          email:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("GetOrderInfo may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "GetOrderInfo", args: {
              email: email,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::OrderInfo)
      end
      sig {params(
          varargs: T.untyped,
          query: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::SearchParams)}
      def GetQuery(
          *varargs,
          query:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("GetQuery may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "GetQuery", args: {
              query: query,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::SearchParams)
      end
      sig {params(
          varargs: T.untyped,
          i1: T::Hash[BamlClient::Types::MapKey, String],i2: T::Hash[BamlClient::Types::MapKey, String],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Hash[BamlClient::Types::MapKey, String])}
      def InOutEnumMapKey(
          *varargs,
          i1:,i2:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("InOutEnumMapKey may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "InOutEnumMapKey", args: {
              i1: i1,i2: i2,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Hash[BamlClient::Types::MapKey, String])
      end
      sig {params(
          varargs: T.untyped,
          i1: T::Hash[T.any(String, String, String, String), String],i2: T::Hash[T.any(String, String, String, String), String],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Hash[T.any(String, String, String, String), String])}
      def InOutLiteralStringUnionMapKey(
          *varargs,
          i1:,i2:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("InOutLiteralStringUnionMapKey may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "InOutLiteralStringUnionMapKey", args: {
              i1: i1,i2: i2,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Hash[T.any(String, String, String, String), String])
      end
      sig {params(
          varargs: T.untyped,
          m: T::Hash[String, String],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Hash[String, String])}
      def InOutSingleLiteralStringMapKey(
          *varargs,
          m:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("InOutSingleLiteralStringMapKey may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "InOutSingleLiteralStringMapKey", args: {
              m: m,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Hash[String, String])
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::JsonValue,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::JsonValue)}
      def JsonTypeAliasCycle(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("JsonTypeAliasCycle may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "JsonTypeAliasCycle", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::JsonValue)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def LLMEcho(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("LLMEcho may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "LLMEcho", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T.any(Integer, T::Boolean, String))}
      def LiteralUnionsTest(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("LiteralUnionsTest may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "LiteralUnionsTest", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T.any(Integer, T::Boolean, String))
      end
      sig {params(
          varargs: T.untyped,
          n: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Integer)}
      def LlmReturnNumber(
          *varargs,
          n:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("LlmReturnNumber may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "LlmReturnNumber", args: {
              n: n,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(Integer)
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::Checked[BamlClient::Types::BlockConstraint])}
      def MakeBlockConstraint(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("MakeBlockConstraint may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "MakeBlockConstraint", args: {

          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::Checked[BamlClient::Types::BlockConstraint])
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::ClassWithBlockDone)}
      def MakeClassWithBlockDone(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("MakeClassWithBlockDone may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "MakeClassWithBlockDone", args: {

          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::ClassWithBlockDone)
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::ClassWithoutDone)}
      def MakeClassWithExternalDone(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("MakeClassWithExternalDone may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "MakeClassWithExternalDone", args: {

          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::ClassWithoutDone)
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::NestedBlockConstraint)}
      def MakeNestedBlockConstraint(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("MakeNestedBlockConstraint may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "MakeNestedBlockConstraint", args: {

          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::NestedBlockConstraint)
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::SemanticContainer)}
      def MakeSemanticContainer(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("MakeSemanticContainer may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "MakeSemanticContainer", args: {

          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::SemanticContainer)
      end
      sig {params(
          varargs: T.untyped,
          m: T::Hash[String, T::Array[String]],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Hash[String, T::Array[String]])}
      def MapAlias(
          *varargs,
          m:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("MapAlias may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "MapAlias", args: {
              m: m,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Hash[String, T::Array[String]])
      end
      sig {params(
          varargs: T.untyped,
          money: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::MergeAttrs)}
      def MergeAliasAttributes(
          *varargs,
          money:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("MergeAliasAttributes may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "MergeAliasAttributes", args: {
              money: money,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::MergeAttrs)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::DynamicOutput)}
      def MyFunc(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("MyFunc may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "MyFunc", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::DynamicOutput)
      end
      sig {params(
          varargs: T.untyped,
          c: T.any(Integer, String, T::Boolean, Float, T::Array[String], T::Hash[String, T::Array[String]]),
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T.any(Integer, String, T::Boolean, Float, T::Array[String], T::Hash[String, T::Array[String]]))}
      def NestedAlias(
          *varargs,
          c:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("NestedAlias may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "NestedAlias", args: {
              c: c,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T.any(Integer, String, T::Boolean, Float, T::Array[String], T::Hash[String, T::Array[String]]))
      end
      sig {params(
          varargs: T.untyped,
          s: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::ClassForNullLiteral)}
      def NullLiteralClassHello(
          *varargs,
          s:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("NullLiteralClassHello may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "NullLiteralClassHello", args: {
              s: s,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::ClassForNullLiteral)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def OpenAIGPT4oMissingBaseUrlEnvVar(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("OpenAIGPT4oMissingBaseUrlEnvVar may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "OpenAIGPT4oMissingBaseUrlEnvVar", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          s: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def OpenAIWithAnthropicResponseHello(
          *varargs,
          s:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("OpenAIWithAnthropicResponseHello may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "OpenAIWithAnthropicResponseHello", args: {
              s: s,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Array[T.nilable(BamlClient::Types::OptionalTest_ReturnType)])}
      def OptionalTest_Function(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("OptionalTest_Function may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "OptionalTest_Function", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Array[T.nilable(BamlClient::Types::OptionalTest_ReturnType)])
      end
      sig {params(
          varargs: T.untyped,
          pdf: Baml::Pdf,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def PdfInput(
          *varargs,
          pdf:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PdfInput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "PdfInput", args: {
              pdf: pdf,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          pdf: Baml::Pdf,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def PdfInputAnthropic(
          *varargs,
          pdf:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PdfInputAnthropic may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "PdfInputAnthropic", args: {
              pdf: pdf,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          pdf: Baml::Pdf,prompt: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def PdfInputOpenai(
          *varargs,
          pdf:,prompt:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PdfInputOpenai may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "PdfInputOpenai", args: {
              pdf: pdf,prompt: prompt,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          pdf: Baml::Pdf,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def PdfInputVertex(
          *varargs,
          pdf:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PdfInputVertex may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "PdfInputVertex", args: {
              pdf: pdf,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          name: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::FooAny)}
      def PredictAge(
          *varargs,
          name:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PredictAge may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "PredictAge", args: {
              name: name,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::FooAny)
      end
      sig {params(
          varargs: T.untyped,
          inp: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::Checked[Integer])}
      def PredictAgeBare(
          *varargs,
          inp:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PredictAgeBare may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "PredictAgeBare", args: {
              inp: inp,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::Checked[Integer])
      end
      sig {params(
          varargs: T.untyped,
          p: T.any(Integer, String, T::Boolean, Float),
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T.any(Integer, String, T::Boolean, Float))}
      def PrimitiveAlias(
          *varargs,
          p:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PrimitiveAlias may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "PrimitiveAlias", args: {
              p: p,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T.any(Integer, String, T::Boolean, Float))
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def PromptTestClaude(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PromptTestClaude may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "PromptTestClaude", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def PromptTestClaudeChat(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PromptTestClaudeChat may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "PromptTestClaudeChat", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def PromptTestClaudeChatNoSystem(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PromptTestClaudeChatNoSystem may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "PromptTestClaudeChatNoSystem", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def PromptTestOpenAI(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PromptTestOpenAI may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "PromptTestOpenAI", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def PromptTestOpenAIChat(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PromptTestOpenAIChat may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "PromptTestOpenAIChat", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def PromptTestOpenAIChatNoSystem(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PromptTestOpenAIChatNoSystem may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "PromptTestOpenAIChatNoSystem", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def PromptTestStreaming(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PromptTestStreaming may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "PromptTestStreaming", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::RecAliasOne,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::RecAliasOne)}
      def RecursiveAliasCycle(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("RecursiveAliasCycle may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "RecursiveAliasCycle", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::RecAliasOne)
      end
      sig {params(
          varargs: T.untyped,
          cls: BamlClient::Types::NodeWithAliasIndirection,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::NodeWithAliasIndirection)}
      def RecursiveClassWithAliasIndirection(
          *varargs,
          cls:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("RecursiveClassWithAliasIndirection may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "RecursiveClassWithAliasIndirection", args: {
              cls: cls,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::NodeWithAliasIndirection)
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::RecursiveUnion,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::RecursiveUnion)}
      def RecursiveUnionTest(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("RecursiveUnionTest may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "RecursiveUnionTest", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::RecursiveUnion)
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::RenderTestClass,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def RenderDynamicClass(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("RenderDynamicClass may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "RenderDynamicClass", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          bike: T.any(BamlClient::Types::RenderTestEnum, String),other: T.any(BamlClient::Types::RenderTestEnum, String),
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def RenderDynamicEnum(
          *varargs,
          bike:,other:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("RenderDynamicEnum may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "RenderDynamicEnum", args: {
              bike: bike,other: other,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          money: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::Checked[Integer])}
      def ReturnAliasWithMergedAttributes(
          *varargs,
          money:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ReturnAliasWithMergedAttributes may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ReturnAliasWithMergedAttributes", args: {
              money: money,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::Checked[Integer])
      end
      sig {params(
          varargs: T.untyped,
          inp: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Integer)}
      def ReturnFailingAssert(
          *varargs,
          inp:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ReturnFailingAssert may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ReturnFailingAssert", args: {
              inp: inp,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(Integer)
      end
      sig {params(
          varargs: T.untyped,
          s: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::JsonTemplate)}
      def ReturnJsonEntry(
          *varargs,
          s:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ReturnJsonEntry may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ReturnJsonEntry", args: {
              s: s,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::JsonTemplate)
      end
      sig {params(
          varargs: T.untyped,
          a: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::MalformedConstraints)}
      def ReturnMalformedConstraints(
          *varargs,
          a:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ReturnMalformedConstraints may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ReturnMalformedConstraints", args: {
              a: a,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::MalformedConstraints)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::Schema)}
      def SchemaDescriptions(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("SchemaDescriptions may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "SchemaDescriptions", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::Schema)
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::RecursiveListAlias,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::RecursiveListAlias)}
      def SimpleRecursiveListAlias(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("SimpleRecursiveListAlias may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "SimpleRecursiveListAlias", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::RecursiveListAlias)
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::RecursiveMapAlias,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::RecursiveMapAlias)}
      def SimpleRecursiveMapAlias(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("SimpleRecursiveMapAlias may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "SimpleRecursiveMapAlias", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::RecursiveMapAlias)
      end
      sig {params(
          varargs: T.untyped,
          digits: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::BigNumbers)}
      def StreamBigNumbers(
          *varargs,
          digits:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("StreamBigNumbers may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "StreamBigNumbers", args: {
              digits: digits,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::BigNumbers)
      end
      sig {params(
          varargs: T.untyped,
          theme: String,length: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::TwoStoriesOneTitle)}
      def StreamFailingAssertion(
          *varargs,
          theme:,length:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("StreamFailingAssertion may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "StreamFailingAssertion", args: {
              theme: theme,length: length,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::TwoStoriesOneTitle)
      end
      sig {params(
          varargs: T.untyped,
          theme: String,length: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::TwoStoriesOneTitleCheck)}
      def StreamFailingCheck(
          *varargs,
          theme:,length:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("StreamFailingCheck may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "StreamFailingCheck", args: {
              theme: theme,length: length,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::TwoStoriesOneTitleCheck)
      end
      sig {params(
          varargs: T.untyped,
          digits: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Integer)}
      def StreamOneBigNumber(
          *varargs,
          digits:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("StreamOneBigNumber may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "StreamOneBigNumber", args: {
              digits: digits,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(Integer)
      end
      sig {params(
          varargs: T.untyped,
          digits: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Array[T.any(Integer, String)])}
      def StreamUnionIntegers(
          *varargs,
          digits:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("StreamUnionIntegers may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "StreamUnionIntegers", args: {
              digits: digits,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Array[T.any(Integer, String)])
      end
      sig {params(
          varargs: T.untyped,
          digits: Integer,yapping: T::Boolean,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::CompoundBigNumbers)}
      def StreamingCompoundNumbers(
          *varargs,
          digits:,yapping:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("StreamingCompoundNumbers may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "StreamingCompoundNumbers", args: {
              digits: digits,yapping: yapping,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::CompoundBigNumbers)
      end
      sig {params(
          varargs: T.untyped,
          document_txt: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::Document1559)}
      def StructureDocument1559(
          *varargs,
          document_txt:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("StructureDocument1559 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "StructureDocument1559", args: {
              document_txt: document_txt,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::Document1559)
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::RecursiveAliasDependency,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::RecursiveAliasDependency)}
      def TakeRecAliasDep(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TakeRecAliasDep may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TakeRecAliasDep", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::RecursiveAliasDependency)
      end
      sig {params(
          varargs: T.untyped,
          story: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TellStory(
          *varargs,
          story:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TellStory may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TellStory", args: {
              story: story,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestAbortFallbackChain(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAbortFallbackChain may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestAbortFallbackChain", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestAnthropic(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAnthropic may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestAnthropic", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestAnthropicShorthand(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAnthropicShorthand may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestAnthropicShorthand", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestAws(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAws may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestAws", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestAwsClaude37(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAwsClaude37 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestAwsClaude37", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestAwsInferenceProfile(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAwsInferenceProfile may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestAwsInferenceProfile", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestAwsInvalidAccessKey(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAwsInvalidAccessKey may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestAwsInvalidAccessKey", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestAwsInvalidEndpoint(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAwsInvalidEndpoint may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestAwsInvalidEndpoint", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestAwsInvalidProfile(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAwsInvalidProfile may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestAwsInvalidProfile", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestAwsInvalidRegion(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAwsInvalidRegion may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestAwsInvalidRegion", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestAwsInvalidSessionToken(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAwsInvalidSessionToken may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestAwsInvalidSessionToken", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestAzure(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAzure may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestAzure", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestAzureFailure(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAzureFailure may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestAzureFailure", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestAzureO1NoMaxTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAzureO1NoMaxTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestAzureO1NoMaxTokens", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestAzureO1WithMaxCompletionTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAzureO1WithMaxCompletionTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestAzureO1WithMaxCompletionTokens", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestAzureO1WithMaxTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAzureO1WithMaxTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestAzureO1WithMaxTokens", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestAzureO3NoMaxTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAzureO3NoMaxTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestAzureO3NoMaxTokens", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestAzureO3WithMaxCompletionTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAzureO3WithMaxCompletionTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestAzureO3WithMaxCompletionTokens", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestAzureWithMaxTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAzureWithMaxTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestAzureWithMaxTokens", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,not_cached: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestCaching(
          *varargs,
          input:,not_cached:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestCaching may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestCaching", args: {
              input: input,not_cached: not_cached,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestFallbackClient(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFallbackClient may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestFallbackClient", args: {

          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestFallbackStrategy(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFallbackStrategy may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestFallbackStrategy", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestFallbackToShorthand(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFallbackToShorthand may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestFallbackToShorthand", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          myBool: T::Boolean,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestFnNamedArgsSingleBool(
          *varargs,
          myBool:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleBool may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestFnNamedArgsSingleBool", args: {
              myBool: myBool,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          myArg: BamlClient::Types::NamedArgsSingleClass,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestFnNamedArgsSingleClass(
          *varargs,
          myArg:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleClass may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestFnNamedArgsSingleClass", args: {
              myArg: myArg,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          myArg: T::Array[BamlClient::Types::NamedArgsSingleEnumList],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestFnNamedArgsSingleEnumList(
          *varargs,
          myArg:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleEnumList may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestFnNamedArgsSingleEnumList", args: {
              myArg: myArg,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          myFloat: Float,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestFnNamedArgsSingleFloat(
          *varargs,
          myFloat:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleFloat may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestFnNamedArgsSingleFloat", args: {
              myFloat: myFloat,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          myInt: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestFnNamedArgsSingleInt(
          *varargs,
          myInt:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleInt may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestFnNamedArgsSingleInt", args: {
              myInt: myInt,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          myMap: T::Hash[String, BamlClient::Types::StringToClassEntry],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Hash[String, BamlClient::Types::StringToClassEntry])}
      def TestFnNamedArgsSingleMapStringToClass(
          *varargs,
          myMap:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleMapStringToClass may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestFnNamedArgsSingleMapStringToClass", args: {
              myMap: myMap,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Hash[String, BamlClient::Types::StringToClassEntry])
      end
      sig {params(
          varargs: T.untyped,
          myMap: T::Hash[String, T::Hash[String, String]],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Hash[String, T::Hash[String, String]])}
      def TestFnNamedArgsSingleMapStringToMap(
          *varargs,
          myMap:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleMapStringToMap may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestFnNamedArgsSingleMapStringToMap", args: {
              myMap: myMap,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Hash[String, T::Hash[String, String]])
      end
      sig {params(
          varargs: T.untyped,
          myMap: T::Hash[String, String],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Hash[String, String])}
      def TestFnNamedArgsSingleMapStringToString(
          *varargs,
          myMap:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleMapStringToString may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestFnNamedArgsSingleMapStringToString", args: {
              myMap: myMap,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Hash[String, String])
      end
      sig {params(
          varargs: T.untyped,
          myString: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestFnNamedArgsSingleString(
          *varargs,
          myString:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleString may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestFnNamedArgsSingleString", args: {
              myString: myString,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          myStringArray: T::Array[String],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestFnNamedArgsSingleStringArray(
          *varargs,
          myStringArray:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleStringArray may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestFnNamedArgsSingleStringArray", args: {
              myStringArray: myStringArray,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          myArg: T::Array[String],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T::Array[String])}
      def TestFnNamedArgsSingleStringList(
          *varargs,
          myArg:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleStringList may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestFnNamedArgsSingleStringList", args: {
              myArg: myArg,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T::Array[String])
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestGemini(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestGemini may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestGemini", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestGeminiOpenAiGeneric(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestGeminiOpenAiGeneric may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestGeminiOpenAiGeneric", args: {

          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestGeminiSystem(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestGeminiSystem may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestGeminiSystem", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestGeminiSystemAsChat(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestGeminiSystemAsChat may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestGeminiSystemAsChat", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestGeminiThinking(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestGeminiThinking may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestGeminiThinking", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestGroq(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestGroq may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestGroq", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          img: Baml::Image,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestImageInput(
          *varargs,
          img:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestImageInput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestImageInput", args: {
              img: img,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          img: Baml::Image,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestImageInputAnthropic(
          *varargs,
          img:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestImageInputAnthropic may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestImageInputAnthropic", args: {
              img: img,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          imgs: T::Array[Baml::Image],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestImageListInput(
          *varargs,
          imgs:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestImageListInput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestImageListInput", args: {
              imgs: imgs,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::TestMemoryOutput)}
      def TestMemory(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestMemory may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestMemory", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::TestMemoryOutput)
      end
      sig {params(
          varargs: T.untyped,
          myArg: BamlClient::Types::NamedArgsSingleClass,myArg2: BamlClient::Types::NamedArgsSingleClass,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestMulticlassNamedArgs(
          *varargs,
          myArg:,myArg2:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestMulticlassNamedArgs may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestMulticlassNamedArgs", args: {
              myArg: myArg,myArg2: myArg2,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          myBool: T::Boolean,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestNamedArgsLiteralBool(
          *varargs,
          myBool:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestNamedArgsLiteralBool may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestNamedArgsLiteralBool", args: {
              myBool: myBool,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          myInt: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestNamedArgsLiteralInt(
          *varargs,
          myInt:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestNamedArgsLiteralInt may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestNamedArgsLiteralInt", args: {
              myInt: myInt,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          myString: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestNamedArgsLiteralString(
          *varargs,
          myString:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestNamedArgsLiteralString may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestNamedArgsLiteralString", args: {
              myString: myString,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(T.nilable(String))}
      def TestOllama(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOllama may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOllama", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(T.nilable(String))
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::Haiku)}
      def TestOllamaHaiku(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOllamaHaiku may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOllamaHaiku", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::Haiku)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAI(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAI may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAI", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIDummyClient(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIDummyClient may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIDummyClient", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIGPT4oMini(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIGPT4oMini may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIGPT4oMini", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIGPT4oMini2(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIGPT4oMini2 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIGPT4oMini2", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIGPT4oMini3(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIGPT4oMini3 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIGPT4oMini3", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAILegacyProvider(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAILegacyProvider may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAILegacyProvider", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIO1NoMaxTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIO1NoMaxTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIO1NoMaxTokens", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIO1WithMaxCompletionTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIO1WithMaxCompletionTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIO1WithMaxCompletionTokens", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIO1WithMaxTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIO1WithMaxTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIO1WithMaxTokens", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIProviderWithResponsesType(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIProviderWithResponsesType may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIProviderWithResponsesType", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIResponses(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponses may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIResponses", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          problem: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIResponsesAllRoles(
          *varargs,
          problem:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesAllRoles may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIResponsesAllRoles", args: {
              problem: problem,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIResponsesAutoType(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesAutoType may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIResponsesAutoType", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          topic: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIResponsesConversation(
          *varargs,
          topic:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesConversation may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIResponsesConversation", args: {
              topic: topic,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIResponsesCustomURL(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesCustomURL may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIResponsesCustomURL", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIResponsesDifferentModel(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesDifferentModel may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIResponsesDifferentModel", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIResponsesEndpoint(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesEndpoint may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIResponsesEndpoint", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIResponsesExplicit(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesExplicit may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIResponsesExplicit", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          query: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIResponsesFunctionCall(
          *varargs,
          query:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesFunctionCall may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIResponsesFunctionCall", args: {
              query: query,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          image: T.any(Baml::Image, String, Baml::Pdf, Baml::Audio),
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIResponsesImageInput(
          *varargs,
          image:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesImageInput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIResponsesImageInput", args: {
              image: image,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          problem: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIResponsesReasoning(
          *varargs,
          problem:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesReasoning may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIResponsesReasoning", args: {
              problem: problem,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIResponsesShorthand(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesShorthand may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIResponsesShorthand", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          query: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIResponsesWebSearch(
          *varargs,
          query:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesWebSearch may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIResponsesWebSearch", args: {
              query: query,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIResponsesWithOpenAIResponseType(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesWithOpenAIResponseType may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIResponsesWithOpenAIResponseType", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIShorthand(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIShorthand may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIShorthand", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIWithFinishReasonError(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIWithFinishReasonError may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIWithFinishReasonError", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIWithMaxTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIWithMaxTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIWithMaxTokens", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenAIWithNullMaxTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIWithNullMaxTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenAIWithNullMaxTokens", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenRouterMistralSmall3_1_24b(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenRouterMistralSmall3_1_24b may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenRouterMistralSmall3_1_24b", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          pdf: Baml::Pdf,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestOpenaiResponsesPdfs(
          *varargs,
          pdf:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenaiResponsesPdfs may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestOpenaiResponsesPdfs", args: {
              pdf: pdf,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestRetryConstant(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestRetryConstant may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestRetryConstant", args: {

          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestRetryExponential(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestRetryExponential may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestRetryExponential", args: {

          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestRoundRobinStrategy(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestRoundRobinStrategy may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestRoundRobinStrategy", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestSingleFallbackClient(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestSingleFallbackClient may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestSingleFallbackClient", args: {

          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::CustomStory)}
      def TestThinking(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestThinking may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestThinking", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::CustomStory)
      end
      sig {params(
          varargs: T.untyped,
          question: BamlClient::Types::UniverseQuestionInput,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::UniverseQuestion)}
      def TestUniverseQuestion(
          *varargs,
          question:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestUniverseQuestion may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestUniverseQuestion", args: {
              question: question,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::UniverseQuestion)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestVertex(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestVertex may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestVertex", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestVertexClaude(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestVertexClaude may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestVertexClaude", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def TestVertexWithSystemInstructions(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestVertexWithSystemInstructions may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "TestVertexWithSystemInstructions", args: {

          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: T.any(String, T::Boolean),
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::UnionTest_ReturnType)}
      def UnionTest_Function(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("UnionTest_Function may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "UnionTest_Function", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::UnionTest_ReturnType)
      end
      sig {params(
          varargs: T.untyped,
          inp: BamlClient::Types::BlockConstraintForParam,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Integer)}
      def UseBlockConstraint(
          *varargs,
          inp:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("UseBlockConstraint may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "UseBlockConstraint", args: {
              inp: inp,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(Integer)
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::MaintainFieldOrder,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(BamlClient::Types::MaintainFieldOrder)}
      def UseMaintainFieldOrder(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("UseMaintainFieldOrder may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "UseMaintainFieldOrder", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(BamlClient::Types::MaintainFieldOrder)
      end
      sig {params(
          varargs: T.untyped,
          a: BamlClient::Types::MalformedConstraints2,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Integer)}
      def UseMalformedConstraints(
          *varargs,
          a:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("UseMalformedConstraints may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "UseMalformedConstraints", args: {
              a: a,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(Integer)
      end
      sig {params(
          varargs: T.untyped,
          inp: BamlClient::Types::NestedBlockConstraintForParam,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Integer)}
      def UseNestedBlockConstraint(
          *varargs,
          inp:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("UseNestedBlockConstraint may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "UseNestedBlockConstraint", args: {
              inp: inp,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(Integer)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def ValidateBasicResponses(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ValidateBasicResponses may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ValidateBasicResponses", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def ValidateResponseTypes(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ValidateResponseTypes may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "ValidateResponseTypes", args: {
              input: input,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          vid: Baml::Video,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def VideoInputGemini(
          *varargs,
          vid:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("VideoInputGemini may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "VideoInputGemini", args: {
              vid: vid,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end
      sig {params(
          varargs: T.untyped,
          vid: Baml::Video,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(String)}
      def VideoInputVertex(
          *varargs,
          vid:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("VideoInputVertex may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          result = options.call_function_sync(function_name: "VideoInputVertex", args: {
              vid: vid,
          })

          parsed = result.parsed_using_types(BamlClient::Types, BamlClient::PartialTypes, false)
          # for sorbet we need to cast to the return type since parsed is now the right value
          # We just need to tell sorbet that the return type is the right type
          parsed.cast_to(String)
      end

  end

  class BamlStreamClient
      extend T::Sig

      sig {params(options: BamlClient::Internal::DoNotUseDirectlyCallManager).void}
      def initialize(options)
          @options = options
      end

      sig {params(
          varargs: T.untyped,
          recipe: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::Recipe, BamlClient::Types::Recipe])}
      def AaaSamOutputFormat(
          *varargs,
          recipe:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AaaSamOutputFormat may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "AaaSamOutputFormat", args: {
              recipe: recipe,
          })

          Baml::BamlStream[BamlClient::StreamTypes::Recipe, BamlClient::Types::Recipe].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          data: BamlClient::Types::LinkedListAliasNode,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::LinkedListAliasNode, BamlClient::Types::LinkedListAliasNode])}
      def AliasThatPointsToRecursiveType(
          *varargs,
          data:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AliasThatPointsToRecursiveType may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "AliasThatPointsToRecursiveType", args: {
              data: data,
          })

          Baml::BamlStream[BamlClient::StreamTypes::LinkedListAliasNode, BamlClient::Types::LinkedListAliasNode].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          money: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::Types::Checked[Integer], BamlClient::Types::Checked[Integer]])}
      def AliasWithMultipleAttrs(
          *varargs,
          money:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AliasWithMultipleAttrs may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "AliasWithMultipleAttrs", args: {
              money: money,
          })

          Baml::BamlStream[BamlClient::Types::Checked[Integer], BamlClient::Types::Checked[Integer]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::InputClass,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def AliasedInputClass(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AliasedInputClass may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "AliasedInputClass", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::InputClass,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def AliasedInputClass2(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AliasedInputClass2 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "AliasedInputClass2", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::InputClassNested,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def AliasedInputClassNested(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AliasedInputClassNested may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "AliasedInputClassNested", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::AliasedEnum,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def AliasedInputEnum(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AliasedInputEnum may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "AliasedInputEnum", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: T::Array[BamlClient::Types::AliasedEnum],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def AliasedInputList(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AliasedInputList may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "AliasedInputList", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          optionals: BamlClient::Types::OptionalListAndMap,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::OptionalListAndMap, BamlClient::Types::OptionalListAndMap])}
      def AllowedOptionals(
          *varargs,
          optionals:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AllowedOptionals may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "AllowedOptionals", args: {
              optionals: optionals,
          })

          Baml::BamlStream[BamlClient::StreamTypes::OptionalListAndMap, BamlClient::Types::OptionalListAndMap].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          a: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[Integer, Integer])}
      def AssertFn(
          *varargs,
          a:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AssertFn may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "AssertFn", args: {
              a: a,
          })

          Baml::BamlStream[Integer, Integer].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          aud: Baml::Audio,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def AudioInput(
          *varargs,
          aud:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AudioInput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "AudioInput", args: {
              aud: aud,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          aud: Baml::Audio,prompt: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def AudioInputOpenai(
          *varargs,
          aud:,prompt:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("AudioInputOpenai may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "AudioInputOpenai", args: {
              aud: aud,prompt: prompt,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: T::Array[Integer],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::LinkedList, BamlClient::Types::LinkedList])}
      def BuildLinkedList(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("BuildLinkedList may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "BuildLinkedList", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::LinkedList, BamlClient::Types::LinkedList].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::BinaryNode,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::Tree, BamlClient::Types::Tree])}
      def BuildTree(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("BuildTree may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "BuildTree", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::Tree, BamlClient::Types::Tree].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          word: String,target: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Boolean, T::Boolean])}
      def CheckWordEquality(
          *varargs,
          word:,target:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("CheckWordEquality may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "CheckWordEquality", args: {
              word: word,target: target,
          })

          Baml::BamlStream[T::Boolean, T::Boolean].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          query: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Array[T.any(BamlClient::Types::AddTodoItem, BamlClient::StreamTypes::TodoMessageToUser)], T::Array[T.any(BamlClient::Types::AddTodoItem, BamlClient::Types::TodoMessageToUser)]])}
      def ChooseTodoTools(
          *varargs,
          query:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ChooseTodoTools may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ChooseTodoTools", args: {
              query: query,
          })

          Baml::BamlStream[T::Array[T.any(BamlClient::Types::AddTodoItem, BamlClient::StreamTypes::TodoMessageToUser)], T::Array[T.any(BamlClient::Types::AddTodoItem, BamlClient::Types::TodoMessageToUser)]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          cls: BamlClient::Types::ClassToRecAlias,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::ClassToRecAlias, BamlClient::Types::ClassToRecAlias])}
      def ClassThatPointsToRecursiveClassThroughAlias(
          *varargs,
          cls:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ClassThatPointsToRecursiveClassThroughAlias may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ClassThatPointsToRecursiveClassThroughAlias", args: {
              cls: cls,
          })

          Baml::BamlStream[BamlClient::StreamTypes::ClassToRecAlias, BamlClient::Types::ClassToRecAlias].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T.any(BamlClient::Types::DynEnumTwo, String), T.any(BamlClient::Types::DynEnumTwo, String)])}
      def ClassifyDynEnumTwo(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ClassifyDynEnumTwo may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ClassifyDynEnumTwo", args: {
              input: input,
          })

          Baml::BamlStream[T.any(BamlClient::Types::DynEnumTwo, String), T.any(BamlClient::Types::DynEnumTwo, String)].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T.any(BamlClient::Types::DynEnumOne, String), T.any(BamlClient::Types::DynEnumOne, String)])}
      def ClassifyDynamicStatus(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ClassifyDynamicStatus may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ClassifyDynamicStatus", args: {
              input: input,
          })

          Baml::BamlStream[T.any(BamlClient::Types::DynEnumOne, String), T.any(BamlClient::Types::DynEnumOne, String)].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::Types::Category, BamlClient::Types::Category])}
      def ClassifyMessage(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ClassifyMessage may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ClassifyMessage", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::Types::Category, BamlClient::Types::Category].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::Types::Category, BamlClient::Types::Category])}
      def ClassifyMessage2(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ClassifyMessage2 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ClassifyMessage2", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::Types::Category, BamlClient::Types::Category].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::Types::Category, BamlClient::Types::Category])}
      def ClassifyMessage3(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ClassifyMessage3 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ClassifyMessage3", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::Types::Category, BamlClient::Types::Category].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          prefix: String,suffix: String,language: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def Completion(
          *varargs,
          prefix:,suffix:,language:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("Completion may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "Completion", args: {
              prefix: prefix,suffix: suffix,language: language,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T.any(BamlClient::StreamTypes::BookOrder, BamlClient::StreamTypes::FlightConfirmation, BamlClient::StreamTypes::GroceryReceipt), T.any(BamlClient::Types::BookOrder, BamlClient::Types::FlightConfirmation, BamlClient::Types::GroceryReceipt)])}
      def CustomTask(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("CustomTask may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "CustomTask", args: {
              input: input,
          })

          Baml::BamlStream[T.any(BamlClient::StreamTypes::BookOrder, BamlClient::StreamTypes::FlightConfirmation, BamlClient::StreamTypes::GroceryReceipt), T.any(BamlClient::Types::BookOrder, BamlClient::Types::FlightConfirmation, BamlClient::Types::GroceryReceipt)].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          audio: Baml::Audio,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def DescribeAudio(
          *varargs,
          audio:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DescribeAudio may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "DescribeAudio", args: {
              audio: audio,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          audio: Baml::Audio,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def DescribeAudio2(
          *varargs,
          audio:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DescribeAudio2 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "DescribeAudio2", args: {
              audio: audio,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          img: Baml::Image,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def DescribeImage(
          *varargs,
          img:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DescribeImage may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "DescribeImage", args: {
              img: img,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          classWithImage: BamlClient::Types::ClassWithImage,img2: Baml::Image,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def DescribeImage2(
          *varargs,
          classWithImage:,img2:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DescribeImage2 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "DescribeImage2", args: {
              classWithImage: classWithImage,img2: img2,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          classWithImage: BamlClient::Types::ClassWithImage,img2: Baml::Image,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def DescribeImage3(
          *varargs,
          classWithImage:,img2:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DescribeImage3 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "DescribeImage3", args: {
              classWithImage: classWithImage,img2: img2,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          classWithImage: BamlClient::Types::ClassWithImage,img2: Baml::Image,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def DescribeImage4(
          *varargs,
          classWithImage:,img2:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DescribeImage4 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "DescribeImage4", args: {
              classWithImage: classWithImage,img2: img2,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          img: Baml::Image,client_sector: String,client_name: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def DescribeMedia1599(
          *varargs,
          img:,client_sector:,client_name:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DescribeMedia1599 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "DescribeMedia1599", args: {
              img: img,client_sector: client_sector,client_name: client_name,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T.any(BamlClient::StreamTypes::OriginalA, BamlClient::StreamTypes::OriginalB), T.any(BamlClient::Types::OriginalA, BamlClient::Types::OriginalB)])}
      def DifferentiateUnions(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DifferentiateUnions may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "DifferentiateUnions", args: {

          })

          Baml::BamlStream[T.any(BamlClient::StreamTypes::OriginalA, BamlClient::StreamTypes::OriginalB), T.any(BamlClient::Types::OriginalA, BamlClient::Types::OriginalB)].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::DummyOutput, BamlClient::Types::DummyOutput])}
      def DummyOutputFunction(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DummyOutputFunction may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "DummyOutputFunction", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::DummyOutput, BamlClient::Types::DummyOutput].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::DynamicClassOne,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::DynamicClassTwo, BamlClient::Types::DynamicClassTwo])}
      def DynamicFunc(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DynamicFunc may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "DynamicFunc", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::DynamicClassTwo, BamlClient::Types::DynamicClassTwo].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::DynInputOutput,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::DynInputOutput, BamlClient::Types::DynInputOutput])}
      def DynamicInputOutput(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DynamicInputOutput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "DynamicInputOutput", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::DynInputOutput, BamlClient::Types::DynInputOutput].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: T::Array[BamlClient::Types::DynInputOutput],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Array[BamlClient::StreamTypes::DynInputOutput], T::Array[BamlClient::Types::DynInputOutput]])}
      def DynamicListInputOutput(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("DynamicListInputOutput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "DynamicListInputOutput", args: {
              input: input,
          })

          Baml::BamlStream[T::Array[BamlClient::StreamTypes::DynInputOutput], T::Array[BamlClient::Types::DynInputOutput]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def ExpectFailure(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExpectFailure may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ExpectFailure", args: {

          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          document: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::ContactInfo, BamlClient::Types::ContactInfo])}
      def ExtractContactInfo(
          *varargs,
          document:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExtractContactInfo may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ExtractContactInfo", args: {
              document: document,
          })

          Baml::BamlStream[BamlClient::StreamTypes::ContactInfo, BamlClient::Types::ContactInfo].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Array[T.any(BamlClient::Types::DynEnumTwo, String)], T::Array[T.any(BamlClient::Types::DynEnumTwo, String)]])}
      def ExtractDynamicCategories(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExtractDynamicCategories may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ExtractDynamicCategories", args: {
              input: input,
          })

          Baml::BamlStream[T::Array[T.any(BamlClient::Types::DynEnumTwo, String)], T::Array[T.any(BamlClient::Types::DynEnumTwo, String)]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          text: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::DynamicSchema, BamlClient::Types::DynamicSchema])}
      def ExtractEntities(
          *varargs,
          text:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExtractEntities may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ExtractEntities", args: {
              text: text,
          })

          Baml::BamlStream[BamlClient::StreamTypes::DynamicSchema, BamlClient::Types::DynamicSchema].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          text: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Array[T.any(BamlClient::Types::Hobby, String)], T::Array[T.any(BamlClient::Types::Hobby, String)]])}
      def ExtractHobby(
          *varargs,
          text:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExtractHobby may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ExtractHobby", args: {
              text: text,
          })

          Baml::BamlStream[T::Array[T.any(BamlClient::Types::Hobby, String)], T::Array[T.any(BamlClient::Types::Hobby, String)]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          text: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def ExtractName(
          *varargs,
          text:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExtractName may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ExtractName", args: {
              text: text,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Array[String], T::Array[String]])}
      def ExtractNames(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExtractNames may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ExtractNames", args: {
              input: input,
          })

          Baml::BamlStream[T::Array[String], T::Array[String]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          text: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Array[BamlClient::StreamTypes::Person], T::Array[BamlClient::Types::Person]])}
      def ExtractPeople(
          *varargs,
          text:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExtractPeople may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ExtractPeople", args: {
              text: text,
          })

          Baml::BamlStream[T::Array[BamlClient::StreamTypes::Person], T::Array[BamlClient::Types::Person]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          email: String,reason: T.any(String, String),
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::ReceiptInfo, BamlClient::Types::ReceiptInfo])}
      def ExtractReceiptInfo(
          *varargs,
          email:,reason:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExtractReceiptInfo may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ExtractReceiptInfo", args: {
              email: email,reason: reason,
          })

          Baml::BamlStream[BamlClient::StreamTypes::ReceiptInfo, BamlClient::Types::ReceiptInfo].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          resume: String,img: T.nilable(Baml::Image),
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::Resume, BamlClient::Types::Resume])}
      def ExtractResume(
          *varargs,
          resume:,img:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExtractResume may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ExtractResume", args: {
              resume: resume,img: img,
          })

          Baml::BamlStream[BamlClient::StreamTypes::Resume, BamlClient::Types::Resume].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          resume: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::Resume, BamlClient::Types::Resume])}
      def ExtractResume2(
          *varargs,
          resume:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ExtractResume2 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ExtractResume2", args: {
              resume: resume,
          })

          Baml::BamlStream[BamlClient::StreamTypes::Resume, BamlClient::Types::Resume].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def FnAlwaysFails(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnAlwaysFails may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnAlwaysFails", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T.nilable(BamlClient::StreamTypes::ClassOptionalOutput), T.nilable(BamlClient::Types::ClassOptionalOutput)])}
      def FnClassOptionalOutput(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnClassOptionalOutput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnClassOptionalOutput", args: {
              input: input,
          })

          Baml::BamlStream[T.nilable(BamlClient::StreamTypes::ClassOptionalOutput), T.nilable(BamlClient::Types::ClassOptionalOutput)].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T.nilable(BamlClient::StreamTypes::ClassOptionalOutput2), T.nilable(BamlClient::Types::ClassOptionalOutput2)])}
      def FnClassOptionalOutput2(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnClassOptionalOutput2 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnClassOptionalOutput2", args: {
              input: input,
          })

          Baml::BamlStream[T.nilable(BamlClient::StreamTypes::ClassOptionalOutput2), T.nilable(BamlClient::Types::ClassOptionalOutput2)].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Array[BamlClient::Types::EnumOutput], T::Array[BamlClient::Types::EnumOutput]])}
      def FnEnumListOutput(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnEnumListOutput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnEnumListOutput", args: {
              input: input,
          })

          Baml::BamlStream[T::Array[BamlClient::Types::EnumOutput], T::Array[BamlClient::Types::EnumOutput]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::Types::EnumOutput, BamlClient::Types::EnumOutput])}
      def FnEnumOutput(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnEnumOutput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnEnumOutput", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::Types::EnumOutput, BamlClient::Types::EnumOutput].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          retries: Integer,delay_ms: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def FnFailRetryConstantDelay(
          *varargs,
          retries:,delay_ms:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnFailRetryConstantDelay may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnFailRetryConstantDelay", args: {
              retries: retries,delay_ms: delay_ms,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          retries: Integer,initial_delay_ms: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def FnFailRetryExponentialDelay(
          *varargs,
          retries:,initial_delay_ms:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnFailRetryExponentialDelay may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnFailRetryExponentialDelay", args: {
              retries: retries,initial_delay_ms: initial_delay_ms,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def FnFallbackAlwaysFails(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnFallbackAlwaysFails may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnFallbackAlwaysFails", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::LiteralClassHello,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::LiteralClassHello, BamlClient::Types::LiteralClassHello])}
      def FnLiteralClassInputOutput(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnLiteralClassInputOutput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnLiteralClassInputOutput", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::LiteralClassHello, BamlClient::Types::LiteralClassHello].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: T.any(BamlClient::Types::LiteralClassOne, BamlClient::Types::LiteralClassTwo),
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T.any(BamlClient::StreamTypes::LiteralClassOne, BamlClient::StreamTypes::LiteralClassTwo), T.any(BamlClient::Types::LiteralClassOne, BamlClient::Types::LiteralClassTwo)])}
      def FnLiteralUnionClassInputOutput(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnLiteralUnionClassInputOutput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnLiteralUnionClassInputOutput", args: {
              input: input,
          })

          Baml::BamlStream[T.any(BamlClient::StreamTypes::LiteralClassOne, BamlClient::StreamTypes::LiteralClassTwo), T.any(BamlClient::Types::LiteralClassOne, BamlClient::Types::LiteralClassTwo)].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          myString: T.nilable(String),
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def FnNamedArgsSingleStringOptional(
          *varargs,
          myString:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnNamedArgsSingleStringOptional may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnNamedArgsSingleStringOptional", args: {
              myString: myString,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Boolean, T::Boolean])}
      def FnOutputBool(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnOutputBool may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnOutputBool", args: {
              input: input,
          })

          Baml::BamlStream[T::Boolean, T::Boolean].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::TestOutputClass, BamlClient::Types::TestOutputClass])}
      def FnOutputClass(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnOutputClass may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnOutputClass", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::TestOutputClass, BamlClient::Types::TestOutputClass].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Array[BamlClient::StreamTypes::TestOutputClass], T::Array[BamlClient::Types::TestOutputClass]])}
      def FnOutputClassList(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnOutputClassList may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnOutputClassList", args: {
              input: input,
          })

          Baml::BamlStream[T::Array[BamlClient::StreamTypes::TestOutputClass], T::Array[BamlClient::Types::TestOutputClass]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::TestClassNested, BamlClient::Types::TestClassNested])}
      def FnOutputClassNested(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnOutputClassNested may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnOutputClassNested", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::TestClassNested, BamlClient::Types::TestClassNested].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::TestClassWithEnum, BamlClient::Types::TestClassWithEnum])}
      def FnOutputClassWithEnum(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnOutputClassWithEnum may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnOutputClassWithEnum", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::TestClassWithEnum, BamlClient::Types::TestClassWithEnum].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[Integer, Integer])}
      def FnOutputInt(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnOutputInt may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnOutputInt", args: {
              input: input,
          })

          Baml::BamlStream[Integer, Integer].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Boolean, T::Boolean])}
      def FnOutputLiteralBool(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnOutputLiteralBool may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnOutputLiteralBool", args: {
              input: input,
          })

          Baml::BamlStream[T::Boolean, T::Boolean].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[Integer, Integer])}
      def FnOutputLiteralInt(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnOutputLiteralInt may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnOutputLiteralInt", args: {
              input: input,
          })

          Baml::BamlStream[Integer, Integer].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def FnOutputLiteralString(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnOutputLiteralString may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnOutputLiteralString", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Array[String], T::Array[String]])}
      def FnOutputStringList(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnOutputStringList may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnOutputStringList", args: {
              input: input,
          })

          Baml::BamlStream[T::Array[String], T::Array[String]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::Types::TestEnum, BamlClient::Types::TestEnum])}
      def FnTestAliasedEnumOutput(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnTestAliasedEnumOutput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnTestAliasedEnumOutput", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::Types::TestEnum, BamlClient::Types::TestEnum].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::TestClassAlias, BamlClient::Types::TestClassAlias])}
      def FnTestClassAlias(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnTestClassAlias may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnTestClassAlias", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::TestClassAlias, BamlClient::Types::TestClassAlias].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          myArg: BamlClient::Types::NamedArgsSingleEnum,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def FnTestNamedArgsSingleEnum(
          *varargs,
          myArg:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("FnTestNamedArgsSingleEnum may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "FnTestNamedArgsSingleEnum", args: {
              myArg: myArg,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          text: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::RaysData, BamlClient::Types::RaysData])}
      def GetDataType(
          *varargs,
          text:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("GetDataType may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "GetDataType", args: {
              text: text,
          })

          Baml::BamlStream[BamlClient::StreamTypes::RaysData, BamlClient::Types::RaysData].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          email: BamlClient::Types::Email,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::OrderInfo, BamlClient::Types::OrderInfo])}
      def GetOrderInfo(
          *varargs,
          email:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("GetOrderInfo may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "GetOrderInfo", args: {
              email: email,
          })

          Baml::BamlStream[BamlClient::StreamTypes::OrderInfo, BamlClient::Types::OrderInfo].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          query: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::SearchParams, BamlClient::Types::SearchParams])}
      def GetQuery(
          *varargs,
          query:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("GetQuery may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "GetQuery", args: {
              query: query,
          })

          Baml::BamlStream[BamlClient::StreamTypes::SearchParams, BamlClient::Types::SearchParams].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          i1: T::Hash[BamlClient::Types::MapKey, String],i2: T::Hash[BamlClient::Types::MapKey, String],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Hash[BamlClient::Types::MapKey, String], T::Hash[BamlClient::Types::MapKey, String]])}
      def InOutEnumMapKey(
          *varargs,
          i1:,i2:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("InOutEnumMapKey may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "InOutEnumMapKey", args: {
              i1: i1,i2: i2,
          })

          Baml::BamlStream[T::Hash[BamlClient::Types::MapKey, String], T::Hash[BamlClient::Types::MapKey, String]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          i1: T::Hash[T.any(String, String, String, String), String],i2: T::Hash[T.any(String, String, String, String), String],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Hash[T.any(String, String, String, String), String], T::Hash[T.any(String, String, String, String), String]])}
      def InOutLiteralStringUnionMapKey(
          *varargs,
          i1:,i2:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("InOutLiteralStringUnionMapKey may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "InOutLiteralStringUnionMapKey", args: {
              i1: i1,i2: i2,
          })

          Baml::BamlStream[T::Hash[T.any(String, String, String, String), String], T::Hash[T.any(String, String, String, String), String]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          m: T::Hash[String, String],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Hash[String, String], T::Hash[String, String]])}
      def InOutSingleLiteralStringMapKey(
          *varargs,
          m:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("InOutSingleLiteralStringMapKey may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "InOutSingleLiteralStringMapKey", args: {
              m: m,
          })

          Baml::BamlStream[T::Hash[String, String], T::Hash[String, String]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::JsonValue,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::JsonValue, BamlClient::Types::JsonValue])}
      def JsonTypeAliasCycle(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("JsonTypeAliasCycle may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "JsonTypeAliasCycle", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::JsonValue, BamlClient::Types::JsonValue].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def LLMEcho(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("LLMEcho may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "LLMEcho", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T.any(Integer, T::Boolean, String), T.any(Integer, T::Boolean, String)])}
      def LiteralUnionsTest(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("LiteralUnionsTest may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "LiteralUnionsTest", args: {
              input: input,
          })

          Baml::BamlStream[T.any(Integer, T::Boolean, String), T.any(Integer, T::Boolean, String)].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          n: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[Integer, Integer])}
      def LlmReturnNumber(
          *varargs,
          n:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("LlmReturnNumber may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "LlmReturnNumber", args: {
              n: n,
          })

          Baml::BamlStream[Integer, Integer].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::Types::Checked[BamlClient::StreamTypes::BlockConstraint], BamlClient::Types::Checked[BamlClient::Types::BlockConstraint]])}
      def MakeBlockConstraint(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("MakeBlockConstraint may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "MakeBlockConstraint", args: {

          })

          Baml::BamlStream[BamlClient::Types::Checked[BamlClient::StreamTypes::BlockConstraint], BamlClient::Types::Checked[BamlClient::Types::BlockConstraint]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::Types::ClassWithBlockDone, BamlClient::Types::ClassWithBlockDone])}
      def MakeClassWithBlockDone(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("MakeClassWithBlockDone may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "MakeClassWithBlockDone", args: {

          })

          Baml::BamlStream[BamlClient::Types::ClassWithBlockDone, BamlClient::Types::ClassWithBlockDone].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::Types::ClassWithoutDone, BamlClient::Types::ClassWithoutDone])}
      def MakeClassWithExternalDone(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("MakeClassWithExternalDone may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "MakeClassWithExternalDone", args: {

          })

          Baml::BamlStream[BamlClient::Types::ClassWithoutDone, BamlClient::Types::ClassWithoutDone].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::NestedBlockConstraint, BamlClient::Types::NestedBlockConstraint])}
      def MakeNestedBlockConstraint(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("MakeNestedBlockConstraint may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "MakeNestedBlockConstraint", args: {

          })

          Baml::BamlStream[BamlClient::StreamTypes::NestedBlockConstraint, BamlClient::Types::NestedBlockConstraint].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::SemanticContainer, BamlClient::Types::SemanticContainer])}
      def MakeSemanticContainer(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("MakeSemanticContainer may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "MakeSemanticContainer", args: {

          })

          Baml::BamlStream[BamlClient::StreamTypes::SemanticContainer, BamlClient::Types::SemanticContainer].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          m: T::Hash[String, T::Array[String]],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Hash[String, T::Array[String]], T::Hash[String, T::Array[String]]])}
      def MapAlias(
          *varargs,
          m:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("MapAlias may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "MapAlias", args: {
              m: m,
          })

          Baml::BamlStream[T::Hash[String, T::Array[String]], T::Hash[String, T::Array[String]]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          money: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::MergeAttrs, BamlClient::Types::MergeAttrs])}
      def MergeAliasAttributes(
          *varargs,
          money:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("MergeAliasAttributes may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "MergeAliasAttributes", args: {
              money: money,
          })

          Baml::BamlStream[BamlClient::StreamTypes::MergeAttrs, BamlClient::Types::MergeAttrs].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::DynamicOutput, BamlClient::Types::DynamicOutput])}
      def MyFunc(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("MyFunc may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "MyFunc", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::DynamicOutput, BamlClient::Types::DynamicOutput].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          c: T.any(Integer, String, T::Boolean, Float, T::Array[String], T::Hash[String, T::Array[String]]),
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T.any(Integer, String, T::Boolean, Float, T::Array[String], T::Hash[String, T::Array[String]]), T.any(Integer, String, T::Boolean, Float, T::Array[String], T::Hash[String, T::Array[String]])])}
      def NestedAlias(
          *varargs,
          c:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("NestedAlias may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "NestedAlias", args: {
              c: c,
          })

          Baml::BamlStream[T.any(Integer, String, T::Boolean, Float, T::Array[String], T::Hash[String, T::Array[String]]), T.any(Integer, String, T::Boolean, Float, T::Array[String], T::Hash[String, T::Array[String]])].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          s: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::ClassForNullLiteral, BamlClient::Types::ClassForNullLiteral])}
      def NullLiteralClassHello(
          *varargs,
          s:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("NullLiteralClassHello may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "NullLiteralClassHello", args: {
              s: s,
          })

          Baml::BamlStream[BamlClient::StreamTypes::ClassForNullLiteral, BamlClient::Types::ClassForNullLiteral].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def OpenAIGPT4oMissingBaseUrlEnvVar(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("OpenAIGPT4oMissingBaseUrlEnvVar may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "OpenAIGPT4oMissingBaseUrlEnvVar", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          s: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def OpenAIWithAnthropicResponseHello(
          *varargs,
          s:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("OpenAIWithAnthropicResponseHello may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "OpenAIWithAnthropicResponseHello", args: {
              s: s,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Array[T.nilable(BamlClient::StreamTypes::OptionalTest_ReturnType)], T::Array[T.nilable(BamlClient::Types::OptionalTest_ReturnType)]])}
      def OptionalTest_Function(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("OptionalTest_Function may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "OptionalTest_Function", args: {
              input: input,
          })

          Baml::BamlStream[T::Array[T.nilable(BamlClient::StreamTypes::OptionalTest_ReturnType)], T::Array[T.nilable(BamlClient::Types::OptionalTest_ReturnType)]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          pdf: Baml::Pdf,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def PdfInput(
          *varargs,
          pdf:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PdfInput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "PdfInput", args: {
              pdf: pdf,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          pdf: Baml::Pdf,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def PdfInputAnthropic(
          *varargs,
          pdf:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PdfInputAnthropic may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "PdfInputAnthropic", args: {
              pdf: pdf,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          pdf: Baml::Pdf,prompt: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def PdfInputOpenai(
          *varargs,
          pdf:,prompt:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PdfInputOpenai may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "PdfInputOpenai", args: {
              pdf: pdf,prompt: prompt,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          pdf: Baml::Pdf,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def PdfInputVertex(
          *varargs,
          pdf:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PdfInputVertex may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "PdfInputVertex", args: {
              pdf: pdf,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          name: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::FooAny, BamlClient::Types::FooAny])}
      def PredictAge(
          *varargs,
          name:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PredictAge may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "PredictAge", args: {
              name: name,
          })

          Baml::BamlStream[BamlClient::StreamTypes::FooAny, BamlClient::Types::FooAny].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          inp: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::Types::Checked[Integer], BamlClient::Types::Checked[Integer]])}
      def PredictAgeBare(
          *varargs,
          inp:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PredictAgeBare may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "PredictAgeBare", args: {
              inp: inp,
          })

          Baml::BamlStream[BamlClient::Types::Checked[Integer], BamlClient::Types::Checked[Integer]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          p: T.any(Integer, String, T::Boolean, Float),
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T.any(Integer, String, T::Boolean, Float), T.any(Integer, String, T::Boolean, Float)])}
      def PrimitiveAlias(
          *varargs,
          p:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PrimitiveAlias may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "PrimitiveAlias", args: {
              p: p,
          })

          Baml::BamlStream[T.any(Integer, String, T::Boolean, Float), T.any(Integer, String, T::Boolean, Float)].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def PromptTestClaude(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PromptTestClaude may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "PromptTestClaude", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def PromptTestClaudeChat(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PromptTestClaudeChat may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "PromptTestClaudeChat", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def PromptTestClaudeChatNoSystem(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PromptTestClaudeChatNoSystem may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "PromptTestClaudeChatNoSystem", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def PromptTestOpenAI(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PromptTestOpenAI may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "PromptTestOpenAI", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def PromptTestOpenAIChat(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PromptTestOpenAIChat may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "PromptTestOpenAIChat", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def PromptTestOpenAIChatNoSystem(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PromptTestOpenAIChatNoSystem may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "PromptTestOpenAIChatNoSystem", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def PromptTestStreaming(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("PromptTestStreaming may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "PromptTestStreaming", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::RecAliasOne,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::RecAliasOne, BamlClient::Types::RecAliasOne])}
      def RecursiveAliasCycle(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("RecursiveAliasCycle may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "RecursiveAliasCycle", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::RecAliasOne, BamlClient::Types::RecAliasOne].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          cls: BamlClient::Types::NodeWithAliasIndirection,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::NodeWithAliasIndirection, BamlClient::Types::NodeWithAliasIndirection])}
      def RecursiveClassWithAliasIndirection(
          *varargs,
          cls:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("RecursiveClassWithAliasIndirection may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "RecursiveClassWithAliasIndirection", args: {
              cls: cls,
          })

          Baml::BamlStream[BamlClient::StreamTypes::NodeWithAliasIndirection, BamlClient::Types::NodeWithAliasIndirection].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::RecursiveUnion,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::RecursiveUnion, BamlClient::Types::RecursiveUnion])}
      def RecursiveUnionTest(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("RecursiveUnionTest may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "RecursiveUnionTest", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::RecursiveUnion, BamlClient::Types::RecursiveUnion].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::RenderTestClass,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def RenderDynamicClass(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("RenderDynamicClass may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "RenderDynamicClass", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          bike: T.any(BamlClient::Types::RenderTestEnum, String),other: T.any(BamlClient::Types::RenderTestEnum, String),
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def RenderDynamicEnum(
          *varargs,
          bike:,other:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("RenderDynamicEnum may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "RenderDynamicEnum", args: {
              bike: bike,other: other,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          money: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::Types::Checked[Integer], BamlClient::Types::Checked[Integer]])}
      def ReturnAliasWithMergedAttributes(
          *varargs,
          money:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ReturnAliasWithMergedAttributes may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ReturnAliasWithMergedAttributes", args: {
              money: money,
          })

          Baml::BamlStream[BamlClient::Types::Checked[Integer], BamlClient::Types::Checked[Integer]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          inp: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[Integer, Integer])}
      def ReturnFailingAssert(
          *varargs,
          inp:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ReturnFailingAssert may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ReturnFailingAssert", args: {
              inp: inp,
          })

          Baml::BamlStream[Integer, Integer].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          s: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::JsonTemplate, BamlClient::Types::JsonTemplate])}
      def ReturnJsonEntry(
          *varargs,
          s:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ReturnJsonEntry may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ReturnJsonEntry", args: {
              s: s,
          })

          Baml::BamlStream[BamlClient::StreamTypes::JsonTemplate, BamlClient::Types::JsonTemplate].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          a: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::MalformedConstraints, BamlClient::Types::MalformedConstraints])}
      def ReturnMalformedConstraints(
          *varargs,
          a:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ReturnMalformedConstraints may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ReturnMalformedConstraints", args: {
              a: a,
          })

          Baml::BamlStream[BamlClient::StreamTypes::MalformedConstraints, BamlClient::Types::MalformedConstraints].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::Schema, BamlClient::Types::Schema])}
      def SchemaDescriptions(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("SchemaDescriptions may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "SchemaDescriptions", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::Schema, BamlClient::Types::Schema].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::RecursiveListAlias,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::RecursiveListAlias, BamlClient::Types::RecursiveListAlias])}
      def SimpleRecursiveListAlias(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("SimpleRecursiveListAlias may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "SimpleRecursiveListAlias", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::RecursiveListAlias, BamlClient::Types::RecursiveListAlias].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::RecursiveMapAlias,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::RecursiveMapAlias, BamlClient::Types::RecursiveMapAlias])}
      def SimpleRecursiveMapAlias(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("SimpleRecursiveMapAlias may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "SimpleRecursiveMapAlias", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::RecursiveMapAlias, BamlClient::Types::RecursiveMapAlias].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          digits: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::BigNumbers, BamlClient::Types::BigNumbers])}
      def StreamBigNumbers(
          *varargs,
          digits:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("StreamBigNumbers may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "StreamBigNumbers", args: {
              digits: digits,
          })

          Baml::BamlStream[BamlClient::StreamTypes::BigNumbers, BamlClient::Types::BigNumbers].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          theme: String,length: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::TwoStoriesOneTitle, BamlClient::Types::TwoStoriesOneTitle])}
      def StreamFailingAssertion(
          *varargs,
          theme:,length:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("StreamFailingAssertion may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "StreamFailingAssertion", args: {
              theme: theme,length: length,
          })

          Baml::BamlStream[BamlClient::StreamTypes::TwoStoriesOneTitle, BamlClient::Types::TwoStoriesOneTitle].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          theme: String,length: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::TwoStoriesOneTitleCheck, BamlClient::Types::TwoStoriesOneTitleCheck])}
      def StreamFailingCheck(
          *varargs,
          theme:,length:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("StreamFailingCheck may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "StreamFailingCheck", args: {
              theme: theme,length: length,
          })

          Baml::BamlStream[BamlClient::StreamTypes::TwoStoriesOneTitleCheck, BamlClient::Types::TwoStoriesOneTitleCheck].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          digits: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[Integer, Integer])}
      def StreamOneBigNumber(
          *varargs,
          digits:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("StreamOneBigNumber may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "StreamOneBigNumber", args: {
              digits: digits,
          })

          Baml::BamlStream[Integer, Integer].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          digits: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Array[T.any(Integer, String)], T::Array[T.any(Integer, String)]])}
      def StreamUnionIntegers(
          *varargs,
          digits:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("StreamUnionIntegers may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "StreamUnionIntegers", args: {
              digits: digits,
          })

          Baml::BamlStream[T::Array[T.any(Integer, String)], T::Array[T.any(Integer, String)]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          digits: Integer,yapping: T::Boolean,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::CompoundBigNumbers, BamlClient::Types::CompoundBigNumbers])}
      def StreamingCompoundNumbers(
          *varargs,
          digits:,yapping:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("StreamingCompoundNumbers may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "StreamingCompoundNumbers", args: {
              digits: digits,yapping: yapping,
          })

          Baml::BamlStream[BamlClient::StreamTypes::CompoundBigNumbers, BamlClient::Types::CompoundBigNumbers].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          document_txt: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::Document1559, BamlClient::Types::Document1559])}
      def StructureDocument1559(
          *varargs,
          document_txt:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("StructureDocument1559 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "StructureDocument1559", args: {
              document_txt: document_txt,
          })

          Baml::BamlStream[BamlClient::StreamTypes::Document1559, BamlClient::Types::Document1559].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::RecursiveAliasDependency,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::RecursiveAliasDependency, BamlClient::Types::RecursiveAliasDependency])}
      def TakeRecAliasDep(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TakeRecAliasDep may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TakeRecAliasDep", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::RecursiveAliasDependency, BamlClient::Types::RecursiveAliasDependency].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          story: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TellStory(
          *varargs,
          story:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TellStory may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TellStory", args: {
              story: story,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestAbortFallbackChain(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAbortFallbackChain may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestAbortFallbackChain", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestAnthropic(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAnthropic may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestAnthropic", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestAnthropicShorthand(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAnthropicShorthand may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestAnthropicShorthand", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestAws(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAws may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestAws", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestAwsClaude37(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAwsClaude37 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestAwsClaude37", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestAwsInferenceProfile(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAwsInferenceProfile may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestAwsInferenceProfile", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestAwsInvalidAccessKey(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAwsInvalidAccessKey may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestAwsInvalidAccessKey", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestAwsInvalidEndpoint(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAwsInvalidEndpoint may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestAwsInvalidEndpoint", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestAwsInvalidProfile(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAwsInvalidProfile may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestAwsInvalidProfile", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestAwsInvalidRegion(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAwsInvalidRegion may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestAwsInvalidRegion", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestAwsInvalidSessionToken(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAwsInvalidSessionToken may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestAwsInvalidSessionToken", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestAzure(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAzure may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestAzure", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestAzureFailure(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAzureFailure may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestAzureFailure", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestAzureO1NoMaxTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAzureO1NoMaxTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestAzureO1NoMaxTokens", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestAzureO1WithMaxCompletionTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAzureO1WithMaxCompletionTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestAzureO1WithMaxCompletionTokens", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestAzureO1WithMaxTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAzureO1WithMaxTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestAzureO1WithMaxTokens", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestAzureO3NoMaxTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAzureO3NoMaxTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestAzureO3NoMaxTokens", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestAzureO3WithMaxCompletionTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAzureO3WithMaxCompletionTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestAzureO3WithMaxCompletionTokens", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestAzureWithMaxTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestAzureWithMaxTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestAzureWithMaxTokens", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,not_cached: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestCaching(
          *varargs,
          input:,not_cached:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestCaching may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestCaching", args: {
              input: input,not_cached: not_cached,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestFallbackClient(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFallbackClient may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestFallbackClient", args: {

          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestFallbackStrategy(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFallbackStrategy may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestFallbackStrategy", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestFallbackToShorthand(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFallbackToShorthand may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestFallbackToShorthand", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          myBool: T::Boolean,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestFnNamedArgsSingleBool(
          *varargs,
          myBool:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleBool may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestFnNamedArgsSingleBool", args: {
              myBool: myBool,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          myArg: BamlClient::Types::NamedArgsSingleClass,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestFnNamedArgsSingleClass(
          *varargs,
          myArg:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleClass may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestFnNamedArgsSingleClass", args: {
              myArg: myArg,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          myArg: T::Array[BamlClient::Types::NamedArgsSingleEnumList],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestFnNamedArgsSingleEnumList(
          *varargs,
          myArg:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleEnumList may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestFnNamedArgsSingleEnumList", args: {
              myArg: myArg,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          myFloat: Float,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestFnNamedArgsSingleFloat(
          *varargs,
          myFloat:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleFloat may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestFnNamedArgsSingleFloat", args: {
              myFloat: myFloat,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          myInt: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestFnNamedArgsSingleInt(
          *varargs,
          myInt:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleInt may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestFnNamedArgsSingleInt", args: {
              myInt: myInt,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          myMap: T::Hash[String, BamlClient::Types::StringToClassEntry],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Hash[String, BamlClient::StreamTypes::StringToClassEntry], T::Hash[String, BamlClient::Types::StringToClassEntry]])}
      def TestFnNamedArgsSingleMapStringToClass(
          *varargs,
          myMap:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleMapStringToClass may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestFnNamedArgsSingleMapStringToClass", args: {
              myMap: myMap,
          })

          Baml::BamlStream[T::Hash[String, BamlClient::StreamTypes::StringToClassEntry], T::Hash[String, BamlClient::Types::StringToClassEntry]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          myMap: T::Hash[String, T::Hash[String, String]],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Hash[String, T::Hash[String, String]], T::Hash[String, T::Hash[String, String]]])}
      def TestFnNamedArgsSingleMapStringToMap(
          *varargs,
          myMap:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleMapStringToMap may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestFnNamedArgsSingleMapStringToMap", args: {
              myMap: myMap,
          })

          Baml::BamlStream[T::Hash[String, T::Hash[String, String]], T::Hash[String, T::Hash[String, String]]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          myMap: T::Hash[String, String],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Hash[String, String], T::Hash[String, String]])}
      def TestFnNamedArgsSingleMapStringToString(
          *varargs,
          myMap:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleMapStringToString may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestFnNamedArgsSingleMapStringToString", args: {
              myMap: myMap,
          })

          Baml::BamlStream[T::Hash[String, String], T::Hash[String, String]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          myString: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestFnNamedArgsSingleString(
          *varargs,
          myString:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleString may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestFnNamedArgsSingleString", args: {
              myString: myString,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          myStringArray: T::Array[String],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestFnNamedArgsSingleStringArray(
          *varargs,
          myStringArray:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleStringArray may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestFnNamedArgsSingleStringArray", args: {
              myStringArray: myStringArray,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          myArg: T::Array[String],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T::Array[String], T::Array[String]])}
      def TestFnNamedArgsSingleStringList(
          *varargs,
          myArg:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestFnNamedArgsSingleStringList may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestFnNamedArgsSingleStringList", args: {
              myArg: myArg,
          })

          Baml::BamlStream[T::Array[String], T::Array[String]].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestGemini(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestGemini may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestGemini", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestGeminiOpenAiGeneric(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestGeminiOpenAiGeneric may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestGeminiOpenAiGeneric", args: {

          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestGeminiSystem(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestGeminiSystem may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestGeminiSystem", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestGeminiSystemAsChat(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestGeminiSystemAsChat may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestGeminiSystemAsChat", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestGeminiThinking(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestGeminiThinking may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestGeminiThinking", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestGroq(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestGroq may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestGroq", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          img: Baml::Image,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestImageInput(
          *varargs,
          img:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestImageInput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestImageInput", args: {
              img: img,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          img: Baml::Image,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestImageInputAnthropic(
          *varargs,
          img:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestImageInputAnthropic may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestImageInputAnthropic", args: {
              img: img,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          imgs: T::Array[Baml::Image],
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestImageListInput(
          *varargs,
          imgs:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestImageListInput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestImageListInput", args: {
              imgs: imgs,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::TestMemoryOutput, BamlClient::Types::TestMemoryOutput])}
      def TestMemory(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestMemory may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestMemory", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::TestMemoryOutput, BamlClient::Types::TestMemoryOutput].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          myArg: BamlClient::Types::NamedArgsSingleClass,myArg2: BamlClient::Types::NamedArgsSingleClass,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestMulticlassNamedArgs(
          *varargs,
          myArg:,myArg2:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestMulticlassNamedArgs may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestMulticlassNamedArgs", args: {
              myArg: myArg,myArg2: myArg2,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          myBool: T::Boolean,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestNamedArgsLiteralBool(
          *varargs,
          myBool:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestNamedArgsLiteralBool may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestNamedArgsLiteralBool", args: {
              myBool: myBool,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          myInt: Integer,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestNamedArgsLiteralInt(
          *varargs,
          myInt:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestNamedArgsLiteralInt may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestNamedArgsLiteralInt", args: {
              myInt: myInt,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          myString: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestNamedArgsLiteralString(
          *varargs,
          myString:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestNamedArgsLiteralString may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestNamedArgsLiteralString", args: {
              myString: myString,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[T.nilable(String), T.nilable(String)])}
      def TestOllama(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOllama may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOllama", args: {
              input: input,
          })

          Baml::BamlStream[T.nilable(String), T.nilable(String)].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::Haiku, BamlClient::Types::Haiku])}
      def TestOllamaHaiku(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOllamaHaiku may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOllamaHaiku", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::Haiku, BamlClient::Types::Haiku].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAI(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAI may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAI", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIDummyClient(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIDummyClient may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIDummyClient", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIGPT4oMini(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIGPT4oMini may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIGPT4oMini", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIGPT4oMini2(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIGPT4oMini2 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIGPT4oMini2", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIGPT4oMini3(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIGPT4oMini3 may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIGPT4oMini3", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAILegacyProvider(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAILegacyProvider may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAILegacyProvider", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIO1NoMaxTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIO1NoMaxTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIO1NoMaxTokens", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIO1WithMaxCompletionTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIO1WithMaxCompletionTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIO1WithMaxCompletionTokens", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIO1WithMaxTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIO1WithMaxTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIO1WithMaxTokens", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIProviderWithResponsesType(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIProviderWithResponsesType may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIProviderWithResponsesType", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIResponses(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponses may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIResponses", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          problem: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIResponsesAllRoles(
          *varargs,
          problem:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesAllRoles may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIResponsesAllRoles", args: {
              problem: problem,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIResponsesAutoType(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesAutoType may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIResponsesAutoType", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          topic: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIResponsesConversation(
          *varargs,
          topic:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesConversation may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIResponsesConversation", args: {
              topic: topic,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIResponsesCustomURL(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesCustomURL may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIResponsesCustomURL", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIResponsesDifferentModel(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesDifferentModel may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIResponsesDifferentModel", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIResponsesEndpoint(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesEndpoint may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIResponsesEndpoint", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIResponsesExplicit(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesExplicit may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIResponsesExplicit", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          query: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIResponsesFunctionCall(
          *varargs,
          query:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesFunctionCall may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIResponsesFunctionCall", args: {
              query: query,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          image: T.any(Baml::Image, String, Baml::Pdf, Baml::Audio),
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIResponsesImageInput(
          *varargs,
          image:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesImageInput may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIResponsesImageInput", args: {
              image: image,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          problem: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIResponsesReasoning(
          *varargs,
          problem:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesReasoning may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIResponsesReasoning", args: {
              problem: problem,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIResponsesShorthand(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesShorthand may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIResponsesShorthand", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          query: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIResponsesWebSearch(
          *varargs,
          query:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesWebSearch may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIResponsesWebSearch", args: {
              query: query,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIResponsesWithOpenAIResponseType(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIResponsesWithOpenAIResponseType may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIResponsesWithOpenAIResponseType", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIShorthand(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIShorthand may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIShorthand", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIWithFinishReasonError(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIWithFinishReasonError may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIWithFinishReasonError", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIWithMaxTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIWithMaxTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIWithMaxTokens", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenAIWithNullMaxTokens(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenAIWithNullMaxTokens may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenAIWithNullMaxTokens", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenRouterMistralSmall3_1_24b(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenRouterMistralSmall3_1_24b may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenRouterMistralSmall3_1_24b", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          pdf: Baml::Pdf,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestOpenaiResponsesPdfs(
          *varargs,
          pdf:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestOpenaiResponsesPdfs may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestOpenaiResponsesPdfs", args: {
              pdf: pdf,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestRetryConstant(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestRetryConstant may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestRetryConstant", args: {

          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestRetryExponential(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestRetryExponential may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestRetryExponential", args: {

          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestRoundRobinStrategy(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestRoundRobinStrategy may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestRoundRobinStrategy", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestSingleFallbackClient(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestSingleFallbackClient may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestSingleFallbackClient", args: {

          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::CustomStory, BamlClient::Types::CustomStory])}
      def TestThinking(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestThinking may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestThinking", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::CustomStory, BamlClient::Types::CustomStory].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          question: BamlClient::Types::UniverseQuestionInput,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::UniverseQuestion, BamlClient::Types::UniverseQuestion])}
      def TestUniverseQuestion(
          *varargs,
          question:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestUniverseQuestion may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestUniverseQuestion", args: {
              question: question,
          })

          Baml::BamlStream[BamlClient::StreamTypes::UniverseQuestion, BamlClient::Types::UniverseQuestion].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestVertex(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestVertex may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestVertex", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestVertexClaude(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestVertexClaude may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestVertexClaude", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,

          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def TestVertexWithSystemInstructions(
          *varargs,

          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("TestVertexWithSystemInstructions may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "TestVertexWithSystemInstructions", args: {

          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: T.any(String, T::Boolean),
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::UnionTest_ReturnType, BamlClient::Types::UnionTest_ReturnType])}
      def UnionTest_Function(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("UnionTest_Function may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "UnionTest_Function", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::UnionTest_ReturnType, BamlClient::Types::UnionTest_ReturnType].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          inp: BamlClient::Types::BlockConstraintForParam,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[Integer, Integer])}
      def UseBlockConstraint(
          *varargs,
          inp:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("UseBlockConstraint may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "UseBlockConstraint", args: {
              inp: inp,
          })

          Baml::BamlStream[Integer, Integer].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: BamlClient::Types::MaintainFieldOrder,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[BamlClient::StreamTypes::MaintainFieldOrder, BamlClient::Types::MaintainFieldOrder])}
      def UseMaintainFieldOrder(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("UseMaintainFieldOrder may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "UseMaintainFieldOrder", args: {
              input: input,
          })

          Baml::BamlStream[BamlClient::StreamTypes::MaintainFieldOrder, BamlClient::Types::MaintainFieldOrder].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          a: BamlClient::Types::MalformedConstraints2,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[Integer, Integer])}
      def UseMalformedConstraints(
          *varargs,
          a:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("UseMalformedConstraints may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "UseMalformedConstraints", args: {
              a: a,
          })

          Baml::BamlStream[Integer, Integer].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          inp: BamlClient::Types::NestedBlockConstraintForParam,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[Integer, Integer])}
      def UseNestedBlockConstraint(
          *varargs,
          inp:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("UseNestedBlockConstraint may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "UseNestedBlockConstraint", args: {
              inp: inp,
          })

          Baml::BamlStream[Integer, Integer].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def ValidateBasicResponses(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ValidateBasicResponses may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ValidateBasicResponses", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          input: String,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def ValidateResponseTypes(
          *varargs,
          input:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("ValidateResponseTypes may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "ValidateResponseTypes", args: {
              input: input,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          vid: Baml::Video,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def VideoInputGemini(
          *varargs,
          vid:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("VideoInputGemini may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "VideoInputGemini", args: {
              vid: vid,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end
      sig {params(
          varargs: T.untyped,
          vid: Baml::Video,
          baml_options: T::Hash[Symbol, T.any(BamlClient::TypeBuilder, Baml::ClientRegistry, T.any(Baml::Collector, T::Array[Baml::Collector]), T::Hash[Symbol, String], T::Hash[String, String])]
      ).returns(Baml::BamlStream[String, String])}
      def VideoInputVertex(
          *varargs,
          vid:,
          baml_options: {}
      )
          if varargs.any?
              raise ArgumentError.new("VideoInputVertex may only be called with keyword arguments")
          end

          options = @options.merge_options(BamlCallOptions.from_hash(baml_options))

          ctx, result = options.create_sync_stream(function_name: "VideoInputVertex", args: {
              vid: vid,
          })

          Baml::BamlStream[String, String].new(
              ffi_stream: result,
              ctx_manager: ctx
          )
      end

  end

end
